Menu Close

Sucesión de Rowland

Definir las siguientes sucesiones

   sucesionA       :: [Integer]
   sucesionB       :: [Integer]
   sucesionRowland :: [Integer]

tales que

  • el término n-ésimo de la sucesionA es a(n) definido por a(1) = 7 y a(n) = a(n-1) + mcd(n, a(n-1)), para n > 1. Por ejemplo,
     λ> take 20 sucesionA
     [7,8,9,10,15,18,19,20,21,22,33,36,37,38,39,40,41,42,43,44]
  • los términos de la sucesionB son las diferencias de los términos consecutivos de la sucesionA. Por ejemplo,
     λ> take 30 sucesionB
     [1,1,1,5,3,1,1,1,1,11,3,1,1,1,1,1,1,1,1,1,1,23,3,1,1,1,1,1,1,1]
  • los términos de la sucesionRowland son los términos de la sucesionB distintos de 1. Por ejemplo,\0
      λ> take 20 sucesionRowland
      [5,3,11,3,23,3,47,3,5,3,101,3,7,11,3,13,233,3,467,3]
      λ> sucesionRowland !! 92
      15567089

Comprobar con QuickCheck que los elementos de la sucesionRowland son números primos.

Nota: Eric S. Rowland demostró en A natural prime-generating recurrence que los elementos de la sucesionRowland son números primos.

Soluciones

import Data.Numbers.Primes (isPrime)
import Test.QuickCheck (Property, (==>), quickCheck)
 
sucesionA :: [Integer]
sucesionA =
   7 : zipWith (+) sucesionA (zipWith gcd sucesionA [2..])
 
sucesionB :: [Integer]
sucesionB = zipWith (-) (tail sucesionA) sucesionA
 
sucesionRowland :: [Integer]
sucesionRowland =  filter (> 1) sucesionB
 
-- La propiedad es
prop_sucesionRowland :: Int -> Property
prop_sucesionRowland n =
  n >= 0 ==> isPrime (sucesionRowland !! n)
 
-- La comprobación es
--    λ> quickCheck prop_sucesionRowland
--    +++ OK, passed 100 tests.

Nuevas soluciones

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

7 soluciones de “Sucesión de Rowland

  1. Rubén Muñoz Mkrtchian
    sucesionA :: [Integer]
    sucesionA = 7 : zipWith (+) sucesionA (zipWith gcd [2..] sucesionA)
     
    sucesionB :: [Integer]
    sucesionB = zipWith (-) (tail sucesionA) sucesionA
     
    sucesionRowland :: [Integer]
    sucesionRowland = eliminaUnos sucesionB
      where eliminaUnos (x:xs) | x == 1    = eliminaUnos xs
                               | otherwise = x : eliminaUnos xs
  2. Juan María Jiménez Jiménez
    sucesionA :: [Integer]
    sucesionA = 7:(fAuxiliar [7])
     
    fAuxiliar :: [Integer] -&gt; [Integer]
    fAuxiliar xs = x:fAuxiliar (xs++[x])
      where x = (last xs) + (gcd (last xs) (genericLength xs+1))
     
    sucesionB :: [Integer]
    sucesionB = zipWith (f) sucesionA (tail sucesionA)
      where f a b = abs (a-b)
     
    sucesionRowland :: [Integer]
    sucesionRowland = filter (/=1) sucesionB
  3. ADOLFO ENRIQUE VÁZQUEZ RUIZ
     
    sucesionA :: [Integer]
    sucesionA = [7] ++ [ (sucesionA!!m) + (listaMcd!!n) | (m,n) <- zip [0..] [0..]]
     
    listaMcd :: [Integer]
    listaMcd = [ gcd x y | (x,y) <- zip sucesionA [2..]]
     
    sucesionB :: [Integer]
    sucesionB = [ x - y | (x,y) <- zip (tail sucesionA) sucesionA]
     
    sucesionRowland :: [Integer]
    sucesionRowland = filter (/= 1) sucesionB
  4. María Ruiz
    sucesionA :: [Integer]
    sucesionA = scanl f 7 [2..]
      where f x y = x + gcd x y
     
    sucesionB :: [Integer]
    sucesionB = zipWith (-) (tail sucesionA) sucesionA
     
    sucesionRowland :: [Integer]
    sucesionRowland = filter (/=1) sucesionB
  5. Mercedes Vega Gallo
    import Data.List
     
    sucesionA :: [Integer]
    sucesionA = map fst $ iterate f (7,2)
                 where f (a,b) = (a+gcd a b,b+1)
     
    sucesionB :: [Integer]
    sucesionB = zipWith (-) (tail sucesionA) sucesionA
     
    sucesionRowland :: [Integer]
    sucesionRowland = concat $ filter p $ group sucesionB
                      where p xs = head xs /=1
  6. Pablo Martín JIménez
     
    sucesionA :: [Integer]
    sucesionA = 7: zipWith (+) sucesionA (zipWith (gcd) [2..] sucesionA)
     
    sucesionB :: [Integer]
    sucesionB = zipWith (-) (tail sucesionA) sucesionA
     
    sucesionRowland :: [Integer]
    sucesionRowland = filter (/=1) sucesionB
  7. Alejandro García Alcaide
    import Data.Numbers.Primes
    -- Definimos la sucesionA de la siguiente forma
    sucesionA  :: [Integer]
    sucesionA  = 7 : zipWith (+) sucesionA (zipWith gcd [2..] sucesionA) 
     
     
    sucesionB :: [Integer]
    sucesionB = [y-x | (x,y) <- zip sucesionA (tail sucesionA)]
     
    sucesionRowland :: [Integer]
    sucesionRowland = filter (/=1) sucesionB
     
    -- Con la funcion propiedad podemos verificar que todos los elementos de dicha
    -- sucesion son primos. 
    propiedad :: Integer -> Bool
    propiedad n = all isPrime (take (fromIntegral n) sucesionRowland)

Leave a Reply to Rubén Muñoz Mkrtchian Cancel reply

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