Menu Close

Cadenas de primos complementarios

José A. Alonso,

El complemento de un número positivo x se calcula por el siguiente procedimiento:

  • si x es mayor que 9, se toma cada dígito por su valor posicional y se resta del mayor los otro dígitos. Por ejemplo, el complemento de 1448 es 1000 – 400 – 40 – 8 = 552. Para
  • si x es menor que 10, su complemento es x.

Definir las funciones

   cadena    :: Integer -> [Integer]
   conCadena :: Int -> [Integer]

tales que

  • (cadena x) es la cadena de primos a partir de x tal que cada uno es el complemento del anterior. Por ejemplo,
     cadena 8         == []
     cadena 7         == [7]
     cadena 13        == [13,7]
     cadena 643       == [643,557,443]
     cadena 18127     == [18127,1873,127,73,67,53,47]
     cadena 18181213  == [18181213,1818787,181213,18787,1213,787,613,587]
  • (conCadena n) es la lista de números cuyas cadenas tienen n elementos. Por ejemplo,
     take 6 (conCadena 3)                == [23,31,61,67,103,307]
     [head (conCadena n) | n <- [4..8]]  == [37,43,157,18127,181873]

Soluciones

 
import Data.Numbers.Primes
 
-- (complemento x) es le complemento de x. Por ejemplo,
--    complemento 1448  == 552
--    complemento  639  == 561
--    complemento    7  == 7
complemento :: Integer -> Integer
complemento x = (div x c)*c - (rem x c)
  where c = 10^(length (show x) - 1)          
 
cadena :: Integer -> [Integer]
cadena x    
  | x < 10 && isPrime x = [x]
  | otherwise           = takeWhile isPrime (iterate f x)
  where f x | x < 10 && isPrime x = 0
            | otherwise           = complemento x
 
conCadena :: Int -> [Integer]
conCadena n =
  [y | y <- primes, length (cadena y) == n]
Inicial
, , , , , , , ,

2 soluciones de “Cadenas de primos complementarios”

  1. Responder
    Enrique Zubiría 
    import Data.Numbers.Primes
 
cadena :: Integer -> [Integer]
cadena x
  | not (isPrime x) = []
  | x == cx         = [x]
  | otherwise       = x : cadena cx
  where cx = foldl1 ((-) . (10*)) [read [c] | c <- show x]
 
conCadena :: Int -> [Integer]
conCadena n = [x | x <- primes, n == length (cadena x)]
  2. Responder
    rafpueleo 
    import Data.Numbers.Primes
 
cadena    :: Int -> [Int]
cadena 0 = []
cadena x
  | isPrime x == False = []
  | x == complemento x = [x]
  | otherwise          = x : cadena (complemento x)
  where
    complemento x
      | x < 10 = x
      | otherwise =
          (head (digitos x)) * 10^(length (digitos x)-1) -
          (complemento2 (x- ((head (digitos x)) * 10^(length (digitos x)-1 ))))
    complemento2 x
      | x < 10 = x
      | otherwise =
          (head (digitos x)) * 10^(length (digitos x)-1) +
          (complemento2 (x- ((head (digitos x)) * 10^(length (digitos x)-1 ))))
 
digitos :: Int -> [Int]
digitos n = [read [x] | x <- show n]
 
conCadena :: Int -> [Integer]
conCadena n =
  [(fromIntegral x) | x <- primes, n == fromIntegral (length (cadena x))]

Escribe tu solución

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