Sucesión de dígitos 0 y 1 alternados

PorJosé A. Alonso 24-enero-201831-enero-2018

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

101

1010

10101

101010

1010101

10101010

101010101

Definir la lista

   sucAlternada :: [Integer]

1	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

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

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

9 Comentarios

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)

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)

Responder

silrommol dice:

24-enero-2018 a las 13:07

Haskell

sucAlternada :: [Integer] sucAlternada = [read (take x aux) | x <- [1..]] where aux = '0' : "1" ++ aux

1
2
3

sucAlternada :: [Integer]
sucAlternada = [read (take x aux) | x <- [1..]]
where aux = '0' : "1" ++ aux

Responder

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

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

Responder

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

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

Responder

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

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

Responder

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

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

Responder

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

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

Responder

Chema Cortés dice:

29-enero-2018 a las 04:30

Haskell

import Data.List sucAlternada :: [Integer] sucAlternada = map read $ (tail.inits.concat.repeat) "01"

1
2
3
4
5

import Data.List

sucAlternada :: [Integer]
sucAlternada = map read
$ (tail.inits.concat.repeat) "01"

Responder

sucAlternada :: [Integer]
sucAlternada = 0 : [sig n | n <- sucAlternada]

sig :: Integer -> Integer
sig x | even x    = 10*x + 1
      | otherwise = 10*x

sucAlternada :: [Integer]

sucAlternada = 0 : [sig n | n <- sucAlternada]

sig :: Integer -> Integer

sig x | even x = 10*x + 1

| otherwise = 10*x

Responder

Sucesión de dígitos 0 y 1 alternados

Soluciones

9 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Se puede imprimir o compartir con

9 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico