Menu Close

Cadenas de primos complementarios

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. 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. 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))]

Leave a Reply

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