Menu Close

Sucesión de dígitos 0 y 1 alternados

Los primeros términos de la sucesión de los dígitos 0 y 1 alternados son

   0
   1
   10
   101
   1010
   10101
   101010
   1010101
   10101010
   101010101

Definir la lista

   sucAlternada :: [Integer]

tal que sus elementos son los términos de la sucesión de los dígitos 0 y 1 alternados. Por ejemplo,

   λ> take 10 sucAlternada
   [0,1,10,101,1010,10101,101010,1010101,10101010,101010101]
   λ> length (show (sucAlternada !! (2*10^6)))
   2000000

Soluciones

import Data.List (inits, unfoldr)
 
-- 1ª solución
-- ===========
 
sucAlternada :: [Integer]
sucAlternada = [read (take x aux) | x <- [1..]]
  where aux = '0' : '1' : aux
 
-- 2ª solución
-- ===========
 
sucAlternada2 :: [Integer]
sucAlternada2 =
  [read (take n (cycle "01")) | n <- [1..]]
 
-- 3ª solución
-- ===========
 
sucAlternada3 :: [Integer]
sucAlternada3 = 0 : [siguiente n | n <- sucAlternada3]
 
siguiente :: Integer -> Integer
siguiente x | even x    = 10*x + 1
            | otherwise = 10*x
 
-- 3ª solución
-- ===========
 
sucAlternada4 :: [Integer]
sucAlternada4 = 0 : map siguiente sucAlternada4
 
-- 5ª solución
-- ===========
 
sucAlternada5 :: [Integer]
sucAlternada5 = map read ((tail . inits . concat . repeat) "01")
 
-- 6ª solución
-- ===========
 
sucAlternada6 :: [Integer]
sucAlternada6 = [(10 * 10^n - 1) `div` 99 | n <- [0..]]
 
-- 7ª solución
-- ===========
 
sucAlternada7 :: [Integer]
sucAlternada7 =
  unfoldr (\x -> if x `mod` 10 == 0
                 then Just (x,10 * x + 1)
                 else Just (x,10 * x))
          0

9 soluciones de “Sucesión de dígitos 0 y 1 alternados

  1. carbremor
    sucAlternada :: [Integer]
    sucAlternada = [sucesion n | n <- [1..]]
     
    sucesion :: Integer -> Integer
    sucesion 1 = 0
    sucesion 2 = 1
    sucesion 3 = 10
    sucesion n = 10 * sucesion (n-1) + sucesion (n-2) - 10 * sucesion (n-3)
     
    -- Eficiencia
    --λ> take 10 sucAlternada
    --[0,1,10,101,1010,10101,101010,1010101,10101010,101010101]
    --(0.01 secs, 121,112 bytes)
  2. silrommol
    sucAlternada :: [Integer]
    sucAlternada = [read (take x aux) | x <- [1..]]
      where aux = '0' : "1" ++ aux
  3. alerodrod5
    sucAlternada :: [Integer]
    sucAlternada = iterate aux 0
      where aux x | last xs == 0 = numero (xs ++ [1])
                  | otherwise    = numero (xs ++ [0])
              where xs = cifras x
     
    cifras :: Integer -> [Integer]
    cifras  x = [read [d] | d <- show x]
     
    numero :: [Integer] -> Integer
    numero xs =
      sum [x*10^y | (x,y) <- zip xs [length xs - 1, length xs - 2..0]]
  4. angruicam1
    import Data.List (unfoldr)
     
    sucAlternada :: [Integer]
    sucAlternada = [(10 * 10^n - 1) `div` 99 | n <- [0..]]
     
    sucAlternada2 :: [Integer]
    sucAlternada2 =
      unfoldr
      (x ->
         if x `mod` 10 == 0
         then Just (x,10 * x + 1)
         else Just (x,10 * x)) 0
  5. luicedval
    sucAlternada :: [Integer]
    sucAlternada = [binario (decimal n) | n <- [1..]]
     
    decimal :: Integer -> Integer
    decimal n | n <= 2    = n - 1
              | odd n     = 2 * decimal (n-1) 
              | otherwise = 1 + 2 * decimal (n-1)
     
    binario :: Integer -> Integer
    binario n | n <= 1    = n
              | otherwise = (mod n 2) + binario (div n 2) * 10
    • luicedval
      numero :: Integer -> Integer
      numero 1 = 0
      numero n | even n    = (numero (n-1)) * 10 + 1
               | otherwise = (numero (n-1)) * 10
       
       
      sucAlternada2 :: [Integer]
      sucAlternada2 = [numero n | n <- [1..]]
  6. menvealer
    list2int1 :: [Integer] -> Integer
    list2int1 [] = 0  
    list2int1 (x:xs) = x*10^(length xs) + list2int1 xs 
     
    sucAlternada :: [Integer]
    sucAlternada = 0 : [list2int1 (take n alternada) | n <- [1..]]
      where alternada :: [Integer]
            alternada = 1 : 0 : alternada
  7. Chema Cortés
    import           Data.List
     
    sucAlternada :: [Integer]
    sucAlternada = map read
                 $ (tail.inits.concat.repeat) "01"
  8. alvblamol
    sucAlternada :: [Integer]
    sucAlternada = 0 : [sig n | n <- sucAlternada]
     
    sig :: Integer -> Integer
    sig x | even x    = 10*x + 1
          | otherwise = 10*x

Leave a Reply

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