Dígitos en la factorización

PorJosé A. Alonso 19-febrero-20162-marzo-2016

El enunciado del problema 652 de Números y algo más es el siguiente

Si factorizamos los factoriales de un número en función de sus divisores primos y sus potencias, ¿Cuál es el menor número n tal que entre los factores primos y los exponentes de estos, n! contiene los dígitos del cero al nueve? Por ejemplo

6! = 2⁴x3²x5¹, le faltan los dígitos 0,6,7,8 y 9

12! = 2¹⁰x3⁵x5²x7¹x11¹, le faltan los dígitos 4,6,8 y 9

Definir la función

   digitosDeFactorizacion :: Integer -> [Integer]

1	digitosDeFactorizacion :: Integer -> [Integer]

tal que (digitosDeFactorizacion n) es el conjunto de los dígitos que aparecen en la factorización de n. Por ejemplo,

   digitosDeFactorizacion (factorial 6)   ==  [1,2,3,4,5]
   digitosDeFactorizacion (factorial 12)  ==  [0,1,2,3,5,7]

1 2	digitosDeFactorizacion (factorial 6) == [1,2,3,4,5] digitosDeFactorizacion (factorial 12) == [0,1,2,3,5,7]

Usando la función anterior, calcular la solución del problema.

Comprobar con QuickCheck que si n es mayor que 100, entonces

   digitosDeFactorizacion (factorial n) == [0..9]

1	digitosDeFactorizacion (factorial n) == [0..9]

Soluciones

import Data.List (genericLength, group, nub, sort)
import Data.Numbers.Primes (primeFactors)
import Test.QuickCheck

-- 1ª definición
-- =============

digitosDeFactorizacion1 :: Integer -> [Integer]
digitosDeFactorizacion1 n =
   sort (nub (concat [digitos x | x <- numerosDeFactorizacion n]))

-- (digitos n) es la lista de los digitos del número n. Por ejemplo, 
--    digitos 320274  ==  [3,2,0,2,7,4]
digitos :: Integer -> [Integer]
digitos n = [read [x] | x <- show n]

-- (numerosDeFactorizacion n) es el conjunto de los números en la
-- factorización de n. Por ejemplo,
--    numerosDeFactorizacion 60  ==  [1,2,3,5]
numerosDeFactorizacion :: Integer -> [Integer]
numerosDeFactorizacion n = 
   sort (nub (aux (factorizacion n)))
   where aux [] = []
         aux ((x,y):zs) = x : y : aux zs

-- (factorización n) es la factorización de n. Por ejemplo,
--    factorizacion 300  ==  [(2,2),(3,1),(5,2)]
factorizacion :: Integer -> [(Integer,Integer)]
factorizacion n = 
    [(head xs, genericLength xs) | xs <- group (factorizacion' n)]

-- (factorizacion' n) es la lista de todos los factores primos de n; es
-- decir, es una lista de números primos cuyo producto es n. Por ejemplo,
--    factorizacion 300  ==  [2,2,3,5,5]
factorizacion' :: Integer -> [Integer]
factorizacion' n | n == 1    = []
                 | otherwise = x : factorizacion' (div n x)
                 where x = menorFactor n

-- (menorFactor n) es el menor factor primo de n. Por ejemplo,
--    menorFactor 15  ==  3
menorFactor :: Integer -> Integer
menorFactor n = head [x | x <- [2..], rem n x == 0]

-- (factorial n) es el factorial de n. Por ejemplo,
--    factorial 5  ==  120
factorial :: Integer -> Integer
factorial n = product [1..n]

-- 2ª definición
-- =============

digitosDeFactorizacion2 :: Integer -> [Integer]
digitosDeFactorizacion2 n =
   sort (nub (concat [digitos x | x <- numerosDeFactorizacion2 n]))

-- (numerosDeFactorizacion2 n) es el conjunto de los números en la
-- factorización de n. Por ejemplo,
--    numerosDeFactorizacion2 60  ==  [1,2,3,5]
numerosDeFactorizacion2 :: Integer -> [Integer]
numerosDeFactorizacion2 n = 
    sort (nub (aux (factorizacion2 n)))
    where aux xs = concat [[a,b] | (a,b) <- xs]

-- (factorización2 n) es la factorización de n. Por ejemplo,
--    factorizacion2 300  ==  [(2,2),(3,1),(5,2)]
factorizacion2 :: Integer -> [(Integer,Integer)]
factorizacion2 n =
    [(head xs, genericLength xs) | xs <- group (primeFactors n)]

-- 3ª definición
-- =============

digitosDeFactorizacion3 :: Integer -> [Integer]
digitosDeFactorizacion3 n =
    sort (nub (concat [digitos x | x <- aux (group (primeFactors n))]))
    where aux  []            = []
          aux (ys@(y:_):xss) = y : genericLength ys : aux xss

-- Definición
-- ==========

digitosDeFactorizacion :: Integer -> [Integer]
digitosDeFactorizacion = digitosDeFactorizacion3

-- Solución
-- ========

-- Para calcular la solución, se define la constante
solucion :: Integer
solucion = 
    head [n | n <- [1..], digitosDeFactorizacion (factorial n) == [0..9]]

-- El cálculo de la solución es
--    ghci> solucion2
--    49

-- Propiedad
-- =========

-- La propiedad es
prop_completa :: Integer -> Bool
prop_completa n =
    digitosDeFactorizacion (factorial n1) == [0..9]
    where n1 = 101 + abs n

-- La comprobación es
--    λ> quickCheck prop_completa
--    +++ OK, passed 100 tests.

100

101

102

103

104

105

106

107

108

109

import Data.List (genericLength, group, nub, sort)

import Data.Numbers.Primes (primeFactors)

import Test.QuickCheck

-- 1ª definición

-- =============

digitosDeFactorizacion1 :: Integer -> [Integer]

digitosDeFactorizacion1 n =

sort (nub (concat [digitos x | x <- numerosDeFactorizacion n]))

-- (digitos n) es la lista de los digitos del número n. Por ejemplo,

-- digitos 320274 == [3,2,0,2,7,4]

digitos :: Integer -> [Integer]

digitos n = [read [x] | x <- show n]

-- (numerosDeFactorizacion n) es el conjunto de los números en la

-- factorización de n. Por ejemplo,

-- numerosDeFactorizacion 60 == [1,2,3,5]

numerosDeFactorizacion :: Integer -> [Integer]

numerosDeFactorizacion n =

sort (nub (aux (factorizacion n)))

where aux [] = []

aux ((x,y):zs) = x : y : aux zs

-- (factorización n) es la factorización de n. Por ejemplo,

-- factorizacion 300 == [(2,2),(3,1),(5,2)]

factorizacion :: Integer -> [(Integer,Integer)]

factorizacion n =

[(head xs, genericLength xs) | xs <- group (factorizacion' n)]

-- (factorizacion' n) es la lista de todos los factores primos de n; es

-- decir, es una lista de números primos cuyo producto es n. Por ejemplo,

-- factorizacion 300 == [2,2,3,5,5]

factorizacion' :: Integer -> [Integer]

factorizacion' n | n == 1 = []

| otherwise = x : factorizacion' (div n x)

where x = menorFactor n

-- (menorFactor n) es el menor factor primo de n. Por ejemplo,

-- menorFactor 15 == 3

menorFactor :: Integer -> Integer

menorFactor n = head [x | x <- [2..], rem n x == 0]

-- (factorial n) es el factorial de n. Por ejemplo,

-- factorial 5 == 120

factorial :: Integer -> Integer

factorial n = product [1..n]

-- 2ª definición

-- =============

digitosDeFactorizacion2 :: Integer -> [Integer]

digitosDeFactorizacion2 n =

sort (nub (concat [digitos x | x <- numerosDeFactorizacion2 n]))

-- (numerosDeFactorizacion2 n) es el conjunto de los números en la

-- factorización de n. Por ejemplo,

-- numerosDeFactorizacion2 60 == [1,2,3,5]

numerosDeFactorizacion2 :: Integer -> [Integer]

numerosDeFactorizacion2 n =

sort (nub (aux (factorizacion2 n)))

where aux xs = concat [[a,b] | (a,b) <- xs]

-- (factorización2 n) es la factorización de n. Por ejemplo,

-- factorizacion2 300 == [(2,2),(3,1),(5,2)]

factorizacion2 :: Integer -> [(Integer,Integer)]

factorizacion2 n =

[(head xs, genericLength xs) | xs <- group (primeFactors n)]

-- 3ª definición

-- =============

digitosDeFactorizacion3 :: Integer -> [Integer]

digitosDeFactorizacion3 n =

sort (nub (concat [digitos x | x <- aux (group (primeFactors n))]))

where aux [] = []

aux (ys@(y:_):xss) = y : genericLength ys : aux xss

-- Definición

-- ==========

digitosDeFactorizacion :: Integer -> [Integer]

digitosDeFactorizacion = digitosDeFactorizacion3

-- Solución

-- ========

-- Para calcular la solución, se define la constante

solucion :: Integer

solucion =

head [n | n <- [1..], digitosDeFactorizacion (factorial n) == [0..9]]

-- El cálculo de la solución es

-- ghci> solucion2

-- 49

-- Propiedad

-- =========

-- La propiedad es

prop_completa :: Integer -> Bool

prop_completa n =

digitosDeFactorizacion (factorial n1) == [0..9]

where n1 = 101 + abs n

-- La comprobación es

-- λ> quickCheck prop_completa

-- +++ OK, passed 100 tests.

La solución en Maxima

/* digitos(n) es la lista de los digitos del número n. Por ejemplo, 
      digitos (320274) == [3,2,0,2,7,4]
*/      
digitos (n) := charlist (string (n))$

digitosDeFactorizacion (n) :=
   unique (apply (append, map (digitos, apply (append, ifactors (n))))) $

solucion () := block ([n:1],
  while length (digitosDeFactorizacion (n!)) < 10 do
     n : n+1,
  n)$   

/*
   (%i5) digitosDeFactorizacion (6!);
   (%o5) [1, 2, 3, 4, 5]

   (%i6) solucion ();
   (%o6) 49
*/

/* digitos(n) es la lista de los digitos del número n. Por ejemplo,

digitos (320274) == [3,2,0,2,7,4]

digitos (n) := charlist (string (n))$

digitosDeFactorizacion (n) :=

unique (apply (append, map (digitos, apply (append, ifactors (n))))) $

solucion () := block ([n:1],

while length (digitosDeFactorizacion (n!)) < 10 do

n : n+1,

n)$

(%i5) digitosDeFactorizacion (6!);

(%o5) [1, 2, 3, 4, 5]

(%i6) solucion ();

(%o6) 49

13 Comentarios

import Data.List
import Data.Numbers.Primes

digitosDeFactorizacion :: Integer -> [Integer]
digitosDeFactorizacion a = 
  sort $ nub $ concat $ map dig $ nub $ aux $ group $ primeFactors a
  where aux :: [[Integer]] -> [Integer]
        aux  []    = []
        aux (ys@(y:_):xss) = y : (genericLength ys) : aux xss
        dig :: Integer -> [Integer]
        dig n = [read [i] | i <- show n]

import Data.List

import Data.Numbers.Primes

digitosDeFactorizacion :: Integer -> [Integer]

digitosDeFactorizacion a =

sort $ nub $ concat $ map dig $ nub $ aux $ group $ primeFactors a

where aux :: [[Integer]] -> [Integer]

aux [] = []

aux (ys@(y:_):xss) = y : (genericLength ys) : aux xss

dig :: Integer -> [Integer]

dig n = [read [i] | i <- show n]

Responder

import Test.QuickCheck

numMayor :: Integer -> Gen Integer
numMayor n = suchThat arbitrary (>n)

prop_digs :: Property
prop_digs = forAll (numMayor 100) 
              (\n -> digitosDeFactorizacion (factorial n) == [0..9])

-- *Main> quickCheck prop_digs
-- +++ OK, passed 100 tests.

import Test.QuickCheck

numMayor :: Integer -> Gen Integer

numMayor n = suchThat arbitrary (>n)

prop_digs :: Property

prop_digs = forAll (numMayor 100)

(\n -> digitosDeFactorizacion (factorial n) == [0..9])

-- *Main> quickCheck prop_digs

-- +++ OK, passed 100 tests.

Responder

import Data.List
import Data.Numbers.Primes

-- Funciones auxiliares:
digitos :: Integer -> [Integer]
digitos n =  [read [a] | a <- show n]

factorial :: Integer -> Integer
factorial n = product [1..n]

-- Función que se pide:
digitosDeFactorizacion :: Integer -> [Integer]
digitosDeFactorizacion = sort.nub.concatMap f.group.primeFactors
    where f xs = concatMap digitos [head xs, genericLength xs]

-- Solución al problema:
menorN :: Integer
menorN = head [n | n <- [1..], digitosDeFactorizacion (factorial n) == [0..9]]

-- λ> menorN
-- 49

-- Y la propiedad a comprobar:
prop_digFact :: Integer -> Property
prop_digFact n = n>0 ==> digitosDeFactorizacion (factorial (n+100)) == [0..9]

-- λ> quickCheck prop_digFact
-- +++ OK, passed 100 tests.

import Data.List

import Data.Numbers.Primes

-- Funciones auxiliares:

digitos :: Integer -> [Integer]

digitos n = [read [a] | a <- show n]

factorial :: Integer -> Integer

factorial n = product [1..n]

-- Función que se pide:

digitosDeFactorizacion :: Integer -> [Integer]

digitosDeFactorizacion = sort.nub.concatMap f.group.primeFactors

where f xs = concatMap digitos [head xs, genericLength xs]

-- Solución al problema:

menorN :: Integer

menorN = head [n | n <- [1..], digitosDeFactorizacion (factorial n) == [0..9]]

-- λ> menorN

-- 49

-- Y la propiedad a comprobar:

prop_digFact :: Integer -> Property

prop_digFact n = n>0 ==> digitosDeFactorizacion (factorial (n+100)) == [0..9]

-- λ> quickCheck prop_digFact

-- +++ OK, passed 100 tests.

Responder

fact :: Integer -> [(Integer,Integer)]
fact n = zip (map head g) (map genericLength g)
         where g = (group . primeFactors) n

digitos :: Integer -> [Integer]
digitos n = [read [i] | i <- show n]

digitosDeFactorizacion :: Integer -> [Integer]
digitosDeFactorizacion n = f (fact n)
                           where f [] = []
                                 f ((a,b):ps) = (nub.sort) (digitos a ++ digitos b ++ f ps)

--La solución a la pregunta es 49
sol :: Integer
sol = 
 head [n | n <- [12..], digitosDeFactorizacion (factorial n) == [0..9]]

fact :: Integer -> [(Integer,Integer)]

fact n = zip (map head g) (map genericLength g)

where g = (group . primeFactors) n

digitos :: Integer -> [Integer]

digitos n = [read [i] | i <- show n]

digitosDeFactorizacion :: Integer -> [Integer]

digitosDeFactorizacion n = f (fact n)

where f [] = []

f ((a,b):ps) = (nub.sort) (digitos a ++ digitos b ++ f ps)

--La solución a la pregunta es 49

sol :: Integer

sol =

head [n | n <- [12..], digitosDeFactorizacion (factorial n) == [0..9]]

Responder

La propiedad:

prop :: Integer -> Property
prop n = n>0 ==> digitosDeFactorizacion (factorial (n+100)) == [0..9]

--λ> quickCheck prop
--+++ OK, passed 100 tests.
--(0.12 secs, 96,100,424 bytes)

prop :: Integer -> Property

prop n = n>0 ==> digitosDeFactorizacion (factorial (n+100)) == [0..9]

--λ> quickCheck prop

--+++ OK, passed 100 tests.

--(0.12 secs, 96,100,424 bytes)

Responder

import Data.Numbers.Primes
import Data.List

digitosDeFactorizacion :: Integer -> [Integer]
digitosDeFactorizacion n = sort.nub $ concat $ map digitos (xss (group (primeFactors n)))
                        
xss [] = []
xss (x:xs) = head x : genericLength x : xss xs

factorial n = product [1..n]

digitos :: Integer -> [Integer]
digitos n = [read [x] | x <- show n]

import Data.Numbers.Primes

import Data.List

digitosDeFactorizacion :: Integer -> [Integer]

digitosDeFactorizacion n = sort.nub $ concat $ map digitos (xss (group (primeFactors n)))

xss [] = []

xss (x:xs) = head x : genericLength x : xss xs

factorial n = product [1..n]

digitos :: Integer -> [Integer]

digitos n = [read [x] | x <- show n]

Responder

erisan dice:

19-febrero-2016 a las 10:33

Ups, me faltaban dos cosas por poner en la definición esta, por ello he subido otra con todo.

Responder

import Data.Numbers.Primes
import Data.List
import Test.QuickCheck

digitosDeFactorizacion :: Integer -> [Integer]
digitosDeFactorizacion n = sort.nub $ concat $ map digitos (xss (group (primeFactors n)))
                        
xss [] = []
xss (x:xs) = head x : genericLength x : xss xs

factorial n = product [1..n]

digitos :: Integer -> [Integer]
digitos n = [read [x] | x <- show n]

prop_digFact :: Integer -> Property
prop_digFact n = n>0 ==> digitosDeFactorizacion (factorial (n+100)) == [0..9]

problema :: Integer
problema = head [n | n <- [1..], digitosDeFactorizacion (factorial n) == [0..9]]

import Data.Numbers.Primes

import Data.List

import Test.QuickCheck

digitosDeFactorizacion :: Integer -> [Integer]

digitosDeFactorizacion n = sort.nub $ concat $ map digitos (xss (group (primeFactors n)))

xss [] = []

xss (x:xs) = head x : genericLength x : xss xs

factorial n = product [1..n]

digitos :: Integer -> [Integer]

digitos n = [read [x] | x <- show n]

prop_digFact :: Integer -> Property

prop_digFact n = n>0 ==> digitosDeFactorizacion (factorial (n+100)) == [0..9]

problema :: Integer

problema = head [n | n <- [1..], digitosDeFactorizacion (factorial n) == [0..9]]

Responder

import Data.Numbers.Primes
import Data.List

Funciones auxiliares:
factorial :: Integer -> Integer
factorial 0 = 1
factorial n = n * factorial (n-1)

digitos :: Integer -> [Integer]
digitos n | n < 10 = [n]
          | otherwise = rem n 10 : digitos (div n 10)

Funciones del ejercicio:
digitosDeFactorizacion :: Integer -> [Integer]
digitosDeFactorizacion n = nub.sort $ digitosExp n ++ 
                digitosBases n

digitosBases :: Integer -> [Integer]
digitosBases n = concatMap digitos $ primeFactors n 

digitosExp :: Integer -> [Integer]
digitosExp n = concatMap digitos $ exponentes n

exponentes :: Integer -> [Integer]
exponentes n = map genericLength $ group(primeFactors n)

menor :: Integer
menor = head [ x | x <- [1..], 
          [0..9] == digitosDeFactorizacion (factorial x)]

import Data.Numbers.Primes

import Data.List

Funciones auxiliares:

factorial :: Integer -> Integer

factorial 0 = 1

factorial n = n * factorial (n-1)

digitos :: Integer -> [Integer]

digitos n | n < 10 = [n]

| otherwise = rem n 10 : digitos (div n 10)

Funciones del ejercicio:

digitosDeFactorizacion :: Integer -> [Integer]

digitosDeFactorizacion n = nub.sort $ digitosExp n ++

digitosBases n

digitosBases :: Integer -> [Integer]

digitosBases n = concatMap digitos $ primeFactors n

digitosExp :: Integer -> [Integer]

digitosExp n = concatMap digitos $ exponentes n

exponentes :: Integer -> [Integer]

exponentes n = map genericLength $ group(primeFactors n)

menor :: Integer

menor = head [ x | x <- [1..],

[0..9] == digitosDeFactorizacion (factorial x)]

Responder

import Data.Numbers.Primes
import Data.List
import Test.QuickCheck

-- Funciones
digitosDeFactorizacion :: Integer -> [Integer]
digitosDeFactorizacion n = sort $ nub $ mayoresQue9 $ nub $
                           fact ++ (exponentes fact) 
                     where fact = primeFactors n


mayoresQue9 :: [Integer] -> [Integer]
mayoresQue9 []     = []
mayoresQue9 (x:xs) | x <= 9    = x:mayoresQue9 xs
                   | otherwise = (digitos x) ++ (mayoresQue9 xs)

exponentes :: [Integer] -> [Integer]
exponentes xs = map genericLength (group xs)

digitos :: Integer -> [Integer]
digitos n = [ read [c] | c <- show n]

factorial :: Integer -> Integer
factorial n = product [1..n]

-- Solución problema
menorNumero = head [ x | x <- [1..], 
              digitosDeFactorizacion (factorial x) == [0..9] ]

-- λ> menorNumero
-- 49

-- Propiedad
propMayor100 :: Integer -> Bool
propMayor100 n = digitosDeFactorizacion (factorial (abs n + 101)) == [0..9]

-- λ> quickCheck propMayor100
-- +++ OK, passed 100 tests.

import Data.Numbers.Primes

import Data.List

import Test.QuickCheck

-- Funciones

digitosDeFactorizacion :: Integer -> [Integer]

digitosDeFactorizacion n = sort $ nub $ mayoresQue9 $ nub $

fact ++ (exponentes fact)

where fact = primeFactors n

mayoresQue9 :: [Integer] -> [Integer]

mayoresQue9 [] = []

mayoresQue9 (x:xs) | x <= 9 = x:mayoresQue9 xs

| otherwise = (digitos x) ++ (mayoresQue9 xs)

exponentes :: [Integer] -> [Integer]

exponentes xs = map genericLength (group xs)

digitos :: Integer -> [Integer]

digitos n = [ read [c] | c <- show n]

factorial :: Integer -> Integer

factorial n = product [1..n]

-- Solución problema

menorNumero = head [ x | x <- [1..],

digitosDeFactorizacion (factorial x) == [0..9] ]

-- λ> menorNumero

-- 49

-- Propiedad

propMayor100 :: Integer -> Bool

propMayor100 n = digitosDeFactorizacion (factorial (abs n + 101)) == [0..9]

-- λ> quickCheck propMayor100

-- +++ OK, passed 100 tests.

Responder

-- Dado un número, calculamos los exponentes de este
 
potencias :: Integer -> [Integer]
potencias n = map (genericLength) (group (primeFactors n))
 
-- Sin embargo, lo que nos interesan son los dígitos
 
potenciasYdigitos :: Integer -> [Integer]
potenciasYdigitos n = nub $ concat [digitos x | x <- potencias n]
 
-- También necesitamos los factores primos. No obstante, si es mayor que 10,
-- nos interesará encontrar sus dígitos

descomposicionYdigitos :: Integer -> [Integer] 
descomposicionYdigitos n = nub $ concat [digitos x | x <- primeFactors n]
 
-- Por tanto, la funcion que nos pide el enunciado es la union de los digitos de
-- los factores y de las potencias
 
digitosDeFactorizacion :: Integer -> [Integer]
digitosDeFactorizacion n  = 
    (sort.nub)$ potenciasYdigitos n  ++ descomposicionYdigitos n
 
-- La solucion a la cuestión es 49
 
primeroQueContieneTodos = 
    head [n | n <- [12..100], digitosDeFactorizacion (factorial n) == [0..9]] 
 
-- La comprobacion queda
 
prop_DigitosFactorizacion :: Integer -> Property
prop_DigitosFactorizacion n = n > 100 ==> digitosDeFactorizacion (factorial n) == [0..9]

-- Fuciones auxiliares empleadas:

digitos :: Integer -> [Integer]
digitos n | n < 10 = [n]
          | otherwise = (rem n 10) : digitos (div n 10)

factorial :: Integer -> Integer
factorial n = product [1..n]

-- Dado un número, calculamos los exponentes de este

potencias :: Integer -> [Integer]

potencias n = map (genericLength) (group (primeFactors n))

-- Sin embargo, lo que nos interesan son los dígitos

potenciasYdigitos :: Integer -> [Integer]

potenciasYdigitos n = nub $ concat [digitos x | x <- potencias n]

-- También necesitamos los factores primos. No obstante, si es mayor que 10,

-- nos interesará encontrar sus dígitos

descomposicionYdigitos :: Integer -> [Integer]

descomposicionYdigitos n = nub $ concat [digitos x | x <- primeFactors n]

-- Por tanto, la funcion que nos pide el enunciado es la union de los digitos de

-- los factores y de las potencias

digitosDeFactorizacion :: Integer -> [Integer]

digitosDeFactorizacion n =

(sort.nub)$ potenciasYdigitos n ++ descomposicionYdigitos n

-- La solucion a la cuestión es 49

primeroQueContieneTodos =

head [n | n <- [12..100], digitosDeFactorizacion (factorial n) == [0..9]]

-- La comprobacion queda

prop_DigitosFactorizacion :: Integer -> Property

prop_DigitosFactorizacion n = n > 100 ==> digitosDeFactorizacion (factorial n) == [0..9]

-- Fuciones auxiliares empleadas:

digitos :: Integer -> [Integer]

digitos n | n < 10 = [n]

| otherwise = (rem n 10) : digitos (div n 10)

factorial :: Integer -> Integer

factorial n = product [1..n]

Responder

import Data.List
import Data.Numbers.Primes
import Test.QuickCheck

digitosDeFactorizacion :: ℤ → String
digitosDeFactorizacion = nub∘sort∘concatMap(λa@(b:_) → show b ⧺ show (length a))∘group∘primeFactors

factorialLleno :: ℤ → Bool
factorialLleno = ("0123456789" ≡) ∘ digitosDeFactorizacion ∘ ∏ ∘ enumFromTo 1

minimoFactorial :: ℤ
minimoFactorial = head $ filter factorialLleno [1…]

prop :: ℤ → Bool
prop = factorialLleno ∘ (101+) ∘ abs

{-
> minimoFactorial 
49
> quickCheck prop
+++ OK, passed 100 tests.
-}

import Data.List

import Data.Numbers.Primes

import Test.QuickCheck

digitosDeFactorizacion :: ℤ → String

digitosDeFactorizacion = nub∘sort∘concatMap(λa@(b:_) → show b ⧺ show (length a))∘group∘primeFactors

factorialLleno :: ℤ → Bool

factorialLleno = ("0123456789" ≡) ∘ digitosDeFactorizacion ∘ ∏ ∘ enumFromTo 1

minimoFactorial :: ℤ

minimoFactorial = head $ filter factorialLleno [1…]

prop :: ℤ → Bool

prop = factorialLleno ∘ (101+) ∘ abs

> minimoFactorial

> quickCheck prop

+++ OK, passed 100 tests.

Responder

Solución con Maxima

digitosDeFactorizacion (n) :=
   unique (apply (append, map (digitos, apply (append, ifactors (n))))) $

digitos (n) := charlist (string (n))$

solucion () := block ([n:1],
  while length (digitosDeFactorizacion (n!)) < 10 do
     n : n+1,
  n)$   

/*
   (%i5) digitosDeFactorizacion (6!);
   (%o5) [1, 2, 3, 4, 5]

   (%i6) solucion ();
   (%o6) 49
*/

digitosDeFactorizacion (n) :=

unique (apply (append, map (digitos, apply (append, ifactors (n))))) $

digitos (n) := charlist (string (n))$

solucion () := block ([n:1],

while length (digitosDeFactorizacion (n!)) < 10 do

n : n+1,

n)$

(%i5) digitosDeFactorizacion (6!);

(%o5) [1, 2, 3, 4, 5]

(%i6) solucion ();

(%o6) 49

Responder

13 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

La solución en Maxima

Se puede imprimir o compartir con

13 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico