Primos magnánimos

PorJosé A. Alonso 20-marzo-202027-marzo-2020

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]

1 2	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

1 2	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]

1 2	λ> 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

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 Comentarios

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

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

Responder

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]

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]

Responder

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

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

Responder

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

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

Responder

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

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

Responder

Primos magnánimos

Soluciones

Otras soluciones

Pensamiento

5 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Otras soluciones

Pensamiento

Se puede imprimir o compartir con

5 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico