Menu Close

Primos magnánimos

Un número magnánimo es un número tal que las sumas obtenidas insertando un “+” entre sus dígitos en cualquier posición son números primos. Por ejemplo, 4001 es un número magnánimo porque los números 4+001=5, 40+01=41 y 400+1=401 son primos.

Definir las funciones

   esMagnanimo :: Integer -> Bool
   primosMagnanimos :: [Integer]

tales que

  • (esMagnanimo n) se verifica si n es un número magnánimo. Por ejemplo,
     esMagnanimo 4001  ==  True
     esMagnanimo 2019  ==  False
  • primosMagnanimos es la lista de los números primos magnánimos. Por ejemplo,
     λ> take 20 primosMagnanimos
     [2,3,5,7,11,23,29,41,43,47,61,67,83,89,101,227,229,281,401,443]

Soluciones

import Data.Numbers.Primes (isPrime, primes)
 
esMagnanimo :: Integer -> Bool
esMagnanimo n =
  all isPrime [x + y | (x, y) <- divisionesNumero n]
 
-- (divisionesNumero n) es la lista de las divisiones de n en dos
-- números. Por ejemplo,
--    divisionesNumero 1234  ==  [(1,234),(12,34),(123,4)]
--    divisionesNumero 234   ==  [(2,34),(23,4)]
--    divisionesNumero 34    ==  [(3,4)]
--    divisionesNumero 4     ==  []
divisionesNumero :: Integer -> [(Integer,Integer)]
divisionesNumero n =
  [(read xs, read ys) | (xs,ys) <- divisiones (show n)]
 
-- (divisiones xs) es la lista de las divisiones de xs en dos listas no
-- vacías. Por ejemplo,
--    divisiones "abcd"  ==  [("a","bcd"),("ab","cd"),("abc","d")]
--    divisiones "bcd"   ==  [("b","cd"),("bc","d")]
--    divisiones "cd"    ==  [("c","d")]
--    divisiones "d"     ==  []
--    divisiones ""      ==  []
divisiones :: [a] -> [([a],[a])]
divisiones []     = []
divisiones [_]    = []
divisiones (x:xs) = ([x],xs) : [(x:is,ds) | (is,ds) <- divisiones xs]
 
primosMagnanimos :: [Integer]
primosMagnanimos = filter esMagnanimo primes

Otras soluciones

  • Se pueden escribir otras soluciones en los comentarios.
  • El código se debe escribir entre una línea con <pre lang="haskell"> y otra con </pre>

Pensamiento

“Existe una distinción entre lo que se puede llamar un problema y lo que puede considerar un ejercicio. Este último sirve para entrenar al en alguna técnica o procedimiento, y requiere poco o ningún original. A diferencia de un ejercicio, un problema, si es apropiado para nivel, debe requerir pensamiento por parte del estudiante. Es imposible exagerar la importancia de los problemas en las matemáticas. Es por medio de los problemas que las matemáticas se desarrollan y se levantan por sí mismas. Cada nuevo descubrimiento en matemáticas es el resultado de un intento de resolver algún problema.”

Howard Eves.

5 soluciones de “Primos magnánimos

  1. melgonaco
    import Data.Numbers.Primes (isPrime, primes)
     
    esMagnanimo :: Integer -> Bool
    esMagnanimo n =
      all isPrime [ digitoEntero xs + digitoEntero ys
                  | a <- [1..length ns - 1]
                  , let (xs, ys) = splitAt a ns]
      where ns = enteroDigito n
     
    enteroDigito :: Integer -> [Integer]
    enteroDigito n = [read [x] | x <- show n]
     
    digitoEntero :: [Integer] -> Integer
    digitoEntero xs = sum [b*10^c | (b,c) <- zip xs [x-1,x-2..0]]
      where x = length xs
     
    primosMagnanimos :: [Integer]
    primosMagnanimos = filter esMagnanimo primes
  2. Carlos Galán
    esMagnanimo :: Integer -> Bool
    esMagnanimo x = all primo [a+b | (a,b) <- zip ps qs]
      where
        ps = [x `div` (10^(numeroDeDigitos x-p)) | p <- [1..numeroDeDigitos x-1]]
        qs = [x `mod` (10^(numeroDeDigitos x-p)) | p <- [1..numeroDeDigitos x-1]]
     
    primosMagnanimos :: [Integer]       
    primosMagnanimos = [x | x <- primos, esMagnanimo x]
     
    -- funciones auxiliares
     
    primos :: [Integer]
    primos = [x | x <- [1..], primo x]
     
    factores :: Integer -> [Integer]
    factores n = [x | x <- [1..n], mod n x == 0]
     
    primo :: Integer -> Bool
    primo x = factores x == [1,x]
     
    numeroDeDigitos :: Integer -> Int
    numeroDeDigitos x = length (digitos x)
     
    digitos :: Integer -> [Integer]
    digitos n = [read [x] | x <- show n]
  3. jespalgon1
    import Data.Numbers.Primes (isPrime, primes)
    import Data.List (genericLength) 
     
    esMagnanimo :: Integer -> Bool
    esMagnanimo n = all isPrime (map sum (particion n))
     
    particion :: Integer -> [[Integer]]
    particion n = [[div n (10^i), rem n (10^i)] | i <- [1..p]]
     where p = genericLength (digitos n)
     
    digitos :: Integer -> [Int]
    digitos n = [read [d] | d <- show n]
     
    primosMagnanimos :: [Integer]
    primosMagnanimos = filter esMagnanimo primes
  4. Enrique Zubiría
    import Data.Numbers.Primes
     
    esMagnanimo :: Integer -> Bool
    esMagnanimo n =
      all isPrime (map (p -> div n (10^p) + rem n (10^p)) [1..l])
      where l = (length $ show n) - 1
     
    primosMagnanimos :: [Integer]
    primosMagnanimos = filter esMagnanimo primes
  5. javjimord
    import Data.Numbers.Primes (isPrime,primes)
    import Data.List (genericLength)
     
    esMagnanimo :: Integer -> Bool
    esMagnanimo n = and [isPrime (x+y) | (x,y) <- zip ps qs]
      where ps = [n `div` (10^p) | p <- [1..m]]
            qs = [n `mod` (10^q) | q <- [1..m]]
            m  = genericLength (show n)
     
    primosMagnanimos :: [Integer]
    primosMagnanimos = filter esMagnanimo primes

Leave a Reply

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