Menu Close

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

José A. Alonso,

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]
Medio
, , , , , , , , , , ,

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

  1. Responder
    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. Responder
    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. Responder
    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. Responder
    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. Responder
    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]
    • Responder
      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. Responder
    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. Responder
    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. Responder
    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. Responder
    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. Responder
    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.