Menu Close

Números cuyos dígitos coinciden con los de sus factores primos

Un número n es especial si al unir los dígitos de sus factores primos, se obtienen exactamente los dígitos de n, aunque puede ser en otro orden. Por ejemplo, 1255 es especial, pues los factores primos de 1255 son 5 y 251.

Definir la función

   esEspecial :: Integer -> Bool

tal que (esEspecial n) se verifica si un número n es especial. Por ejemplo,

   esEspecial 1255 == True
   esEspecial 125  == False
   esEspecial 132  == False

Comprobar con QuickCheck que todo número primo es especial.

Calcular los 5 primeros números especiales que no son primos.

Soluciones

import Data.List (nub, sort)
import Data.Numbers.Primes (isPrime, primeFactors)
import Test.QuickCheck
 
esEspecial :: Integer -> Bool
esEspecial n = 
    sort (show n) == sort (concatMap show (nub (primeFactors n)))
 
-- La propiedad es
prop_primos:: Integer -> Property
prop_primos n = 
    isPrime (abs n) ==> esEspecial (abs n)
 
-- La comprobación es
--    ghci> quickCheck prop_primos
--    +++ OK, passed 100 tests.
 
-- El cálculo es
--    ghci> take 5 [n | n <- [2..], esEspecial n, not (isPrime n)]
--    [735,1255,3792,7236,11913]

11 soluciones de “Números cuyos dígitos coinciden con los de sus factores primos

  1. Paola Cabrera Perza
    import Data.List
    import Test.QuickCheck
    import Data.Numbers.Primes
     
    esEspecial :: Integer -> Bool
    esEspecial n = digitosFactoresPrimos n == digitos2 n
     
    digitosFactoresPrimos :: Integer -> [Integer]
    digitosFactoresPrimos n = sort (concat [digitos2 x | x <- primeFactors n])
     
    digitos2 :: Integer->[Integer]
    digitos2 n = sort [read[c] | c <- show n]
     
    prop_primosesEspecial :: Integer -> Property
    prop_primosesEspecial n = isPrime n ==> esEspecial n
     
    -- *Main> quickCheckWith (stdArgs {maxSize=7}) prop_primosesEspecial
    -- +++ OK, passed 100 tests.
     
    especialesNoPrimos :: [Integer]
    especialesNoPrimos = [x | x <-[1..], esEspecial x, not (isPrime x)]
     
    -- *Main> take 5 especialesNoPrimos
    --[1255,12955,17482,25105,100255]
  2. anaagusil
     
    esEspecial n =  sort (concat xs) == sort (digitos n)
               where xs = [(digitos x) | x <- primeFactors n]
     
    prop_esEspecial :: Integer -> Property
    prop_esEspecial n = isPrime n ==> esEspecial n
     
    -- *Main> quickCheck prop_esEspecial
    -- +++ OK, passed 100 tests.
     
    calculaEsp :: [Integer]
    calculaEsp = [ x | x <- [1..], esEspecial x, not (isPrime x) ]
     
    -- *Main> take 5 calculaEsp
    -- [1255,12955,17482,25105,100255]
  3. erisancha
    import Data.Numbers.Primes
    import Data.List
    import Test.QuickCheck
     
     
    esEspecial :: Integer -> Bool
    esEspecial n = sort (lista n) == sort (factorizacion n)
     
    lista :: Integer -> [Integer]
    lista n = [read [x] | x <- show n]
     
    factorizacion :: Integer -> [Integer]
    factorizacion n = concat [lista z | z <- [x | x <- primeFactors n]]
     
    prop_primosesEspecial :: Integer -> Property
    prop_primosesEspecial n = isPrime n ==> esEspecial n
     
    especialNoPrimo :: [Integer]
    especialNoPrimo = [x | x <- noPrimos, esEspecial x]
     
    noPrimos :: [Integer]
    noPrimos = [x | x <- [1..], not (isPrime x)]
     
    -- *Main> take 5 especialNoPrimo
    --[1255,12955,17482,25105,100255]
  4. erisan
    import Data.Numbers.Primes
    import Data.List
    import Test.QuickCheck
     
     
    esEspecial :: Integer -> Bool
    esEspecial n = sort (lista n) == sort (factorizacion n)
     
    lista :: Integer -> [Integer]
    lista n = [read [x] | x <- show n]
     
    factorizacion :: Integer -> [Integer]
    factorizacion n = concat [lista z | z <- [x | x <- primeFactors n]]
     
    prop_primosesEspecial :: Integer -> Property
    prop_primosesEspecial n = isPrime n ==> esEspecial n
     
    especialNoPrimo :: [Integer]
    especialNoPrimo = [x | x <- noPrimos, esEspecial x]
     
    noPrimos :: [Integer]
    noPrimos = [x | x <- [1..], not (isPrime x)]
     
    -- *Main> take 5 especialNoPrimo
    --[1255,12955,17482,25105,100255]
  5. alvalvdom1
    import Data.Map as M
    import Data.List
    import Data.Numbers.Primes
    import Test.QuickCheck
     
    esEspecial :: Integer -> Bool
    esEspecial n = fromList [(x,nVeces x lista) | x <- lista] == fromList [(x,nVeces x d) | x <- d]
                 where lista = concatMap digitos (primeFactors n)
                       d = digitos n
     
    nVeces :: Integer -> [Integer] -> Integer
    nVeces x xs = genericLength [y | y <- xs, x == y]
     
    digitos :: Integer -> [Integer]
    digitos n = [read [x] | x <- show n]
     
    -- La propiedad es:
    prop_EsEspecial :: Integer -> Property
    prop_EsEspecial n = isPrime n ==> esEspecial n
     
    -- *Main> quickCheck prop_EsEspecial
    -- +++ OK, passed 100 tests.
     
    --El cálculo pedido:
    -- *Main> take 5 $ Prelude.filter (x -> esEspecial x && not (isPrime x)) [1..]
    -- [1255,12955,17482,25105,100255]
    • alvalvdom1
      import Data.Map as M
      import Data.List
      import Data.Numbers.Primes
      import Test.QuickCheck
       
      esEspecial :: Integer -> Bool
      esEspecial n =
        M.fromList [(x,nVeces x lista) | x <- lista] ==
        M.fromList [(x,nVeces x d) | x <- d]
        where lista = concatMap digitos (primeFactors n)
              d = digitos n
       
      nVeces :: Integer -> [Integer] -> Integer
      nVeces x xs = genericLength [y | y <- xs, x == y]
       
      digitos :: Integer -> [Integer]
      digitos n = [read [x] | x <- show n]
       
      -- La propiedad es:
      prop_EsEspecial :: Integer -> Property
      prop_EsEspecial n = isPrime n ==> esEspecial n
       
      -- *Main> quickCheck prop_EsEspecial
      -- +++ OK, passed 100 tests.
       
      --El cálculo pedido:
      -- *Main> take 5 $ Prelude.filter (x -> esEspecial x && not (isPrime x)) [1..]
      -- [1255,12955,17482,25105,100255]
  6. juamorrom1
    -- Mi definición es parecida a algunas anteriores, aunque sin usar la función
    -- (digitos n); en su lugar uso (show n).
     
    import Data.List
    import Data.Numbers.Primes
    import Test.QuickCheck
     
    esEspecial :: Integer -> Bool
    esEspecial n = sort ds == sort ps
               where ps = concat (map show (primeFactors n))
                     ds = show n
     
    -- La propiedad es:
     
    prop :: Integer -> Property
    prop n = isPrime n ==> esEspecial n
     
    -- La comprobación es:
    -- *Main> quickCheck prop
    -- +++ OK, passed 100 tests.
     
    primerosEspeciales :: [Integer]
    primerosEspeciales = take 5 [ x | x <- [1..], not (isPrime x),
                                                  esEspecial x]
     
    -- Los cinco primeros números especiales no primos son:
    -- *Main> primerosEspeciales
    -- [1255,12955,17482,25105,100255]
  7. fracruzam
    import Data.Numbers.Primes
    import Test.QuickCheck
     
    esEspecial :: Integer -> Bool
    esEspecial n = checkCifras (show n) xs []
      where xs = concat $ map show $ primeFactors n
            checkCifras :: String -> String -> String -> Bool
            checkCifras (n:ns) (x:xs) ys
                | n == x    = checkCifras ns (xs++ys) []
                | otherwise = checkCifras (n:ns) xs (x:ys)
            checkCifras []      []    _ = True
            checkCifras _       _     _ = False
     
    genPrimes :: Gen Integer
    genPrimes = suchThat arbitrary isPrime
     
    prop_Primos :: Property
    prop_Primos = forAll genPrimes esEspecial
    -- λ> quickCheck prop_Primos
    -- +++ OK, passed 100 tests.
     
    cincoPrimeros :: [Integer]
    cincoPrimeros = take 5 $ filter especialNoPrimo [1..]
      where especialNoPrimo :: Integer -> Bool
            especialNoPrimo n = esEspecial n && (not . isPrime) n
    -- λ> cincoPrimeros
    -- [1255,12955,17482,25105,100255]
  8. abrdelrod

    Solución en Maxima:

    /* Primero definimos unas cuantas funciones auxiliares para acabar
       definiendo la función que nos da los factores primos de n de forma
       extendida (pues ifactors los da de forma compacta y no he encontrado
       otra función que los dé de forma extendida)
    */
     
     
    concatMap (f,xss) :=
      if length (xss) = 0
      then []
      else append (f (first (xss)), concatMap (f, rest (xss)))$
     
    digitos (n) :=
      if n < 10
      then [n]
      else append (digitos (quotient (n,10)), [mod (n,10)])$
     
    extendida (xss) :=
      if xss = []
      then []
      else append (([a,b] : first (xss), makelist (a,b)), extendida (rest (xss)))$
     
    digitosPrimosFact (n) :=
      concatMap (digitos, extendida (ifactors(n)))$
     
    /* La función esEspecial: */
     
    esEspecialA1 (n) :=
      is (sort (digitos (n)) = sort (digitosPrimosFact (n)))$
     
    /* Y el cálculo de los cinco primeros especiales no primos (no sé como
       pedirle que me calcule los n primeros si no sé dónde está el término
       n). Me he basado en el cálculo que han hecho mis compañeros para
       ponerle una cota superior:  
    */
     
    /*
       sublist (makelist (k,k,1,101000),
                lambda ([x], esEspecialA1 (x) and not (primep (x))));
     
       Evaluation took 44.7340 seconds (44.9540 elapsed) using 1376.423 MB.
       [1255,12955,17482,25105,100255]
    */
  9. Chema Cortés
    import Data.Numbers.Primes
    import Data.List
    import Test.QuickCheck
     
    esEspecial :: Integer -> Bool
    esEspecial n = sort xs == (sort . show) n
        where xs = concatMap show $ primeFactors n
     
    --prop_especial :: Property
    prop_especial :: Property
    prop_especial = forAll (elements smallPrimes) esEspecial
        where smallPrimes = take 100000 primes
     
    -- primeros especiales no primos
    --   1255,12955,17482,25105,100255,...
    primerosEspecialNoPrimos :: [Integer]
    primerosEspecialNoPrimos = [x | x <- [1..]
                                  , esEspecial x
                                  , not (isPrime x) ]
  10. isrbelnun
    import Data.Numbers.Primes
    import Data.List
     
    esEspecial :: Integer -> Bool
    esEspecial n = sort (digitos n) == sort (concatMap digitos (primeFactors n))
     
    digitos :: Integer -> [Int]
    digitos n = [read [c] | c <- show n]

Escribe tu solución

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.