Menu Close

Raíces digitales de sucesiones de raíces digitales

La raíz digital de un número entero positivo n es el dígito que resulta al sumar sus dígitos, volviendo a sumar reiteradamente los resultados de esa suma y de las siguientes hasta que la suma sea un número de un dígito, al que se llama la raíz digital del número n y se representa pod D(n). Por ejemplo, la raíz digital del número 2345 es 6, porque 2+3+4+5+1 = 15 y sumando los dígitos del 15 resulta 6.

La sucesión de las raices digitales definida por un número a es la sucesión a(n) tal que a(0) = a y a(n+1) es la suma de a(n) y la raíz dígital de a(n). Por ejemplo, los primeros términos de la sucesión de las raíces digitales definida por 1 son

   1,2,4,8,16,23,28,29,31,35,43,50,55,56,58,62,70,77,82,83,85,89,...

Definir la función

   raicesDigitalesSucesionRaicesDigitales :: Integer -> [Integer]

tal que (raicesDigitalesSucesionRaicesDigitales a) es la lista de las raíces digitales de los elementos de la sucesión de raíces digitales definidas por a. Por ejemplo,

   λ> take 20 (raicesDigitalesSucesionRaicesDigitales 1)
   [1,2,4,8,7,5,1,2,4,8,7,5,1,2,4,8,7,5,1,2]
   λ> take 20 (raicesDigitalesSucesionRaicesDigitales 2021)
   [5,1,2,4,8,7,5,1,2,4,8,7,5,1,2,4,8,7,5,1]
   λ> raicesDigitalesSucesionRaicesDigitales (9^100) !! (10^9)
   9

Soluciones

import Data.List (cycle)
 
-- 1ª solución
-- ===========
 
raicesDigitalesSucesionRaicesDigitales :: Integer -> [Integer]
raicesDigitalesSucesionRaicesDigitales a =
  map raizDigital (sucesionRaicesDigitales a)
 
-- (sucesionRaicesDigitales a) es la sucesión de las raíces digitales
-- definida por un número a. Por ejemplo,
--    λ> take 22 (sucesionRaicesDigitales 1)
--    [1,2,4,8,16,23,28,29,31,35,43,50,55,56,58,62,70,77,82,83,85,89]
--    λ> take 22 (sucesionRaicesDigitales 3)
--    [3,6,12,15,21,24,30,33,39,42,48,51,57,60,66,69,75,78,84,87,93,96]
--    λ> take 22 (sucesionRaicesDigitales 5)
--    [5,10,11,13,17,25,32,37,38,40,44,52,59,64,65,67,71,79,86,91,92,94]
--    λ> take 22 (sucesionRaicesDigitales 7)
--    [7,14,19,20,22,26,34,41,46,47,49,53,61,68,73,74,76,80,88,95,100,101]
--    λ> take 22 (sucesionRaicesDigitales 9)
--    [9,18,27,36,45,54,63,72,81,90,99,108,117,126,135,144,153,162,171,180,189,198]
sucesionRaicesDigitales :: Integer -> [Integer]
sucesionRaicesDigitales a =
  iterate siguienteRaizDigital a
 
-- (siguienteRaizDigital a) es el siguiente de a en la sucesión de raices
-- digitales. Por ejemplo,
--    siguienteRaizDigital 23 == 28
siguienteRaizDigital :: Integer -> Integer
siguienteRaizDigital a =
  a + raizDigital a
 
-- (raizDigital n) es la raíz digital de n. Por ejemplo,
--    raizDigital 23451  ==  6
raizDigital :: Integer -> Integer
raizDigital n = 1 + (n-1) `mod` 9
 
-- (noPertenece x ys) se verifica si x no pertenece a la lista infinita
-- ordenada creciente ys. Por ejemplo,
--    noPertenece 2 [1,3..] == True
--    noPertenece 5 [1,3..] == False
noPertenece :: Integer -> [Integer] -> Bool
noPertenece x ys =
  not (x `pertenece` ys)
 
-- (Pertenece x ys) se verifica si x pertenece a la lista infinita
-- ordenada creciente ys. Por ejemplo,
--    pertenece 5 [1,3..] == True
--    pertenece 2 [1,3..] == False
pertenece :: Integer -> [Integer] -> Bool
pertenece x ys =
  x == head (dropWhile (<x) ys)
 
-- 2ª solución
-- ===========
 
-- En el ejercicio aterior vimos que sólo hay 5 sucesiones de ríace
-- digitales: las generadas por 1, 3, 5, 7 y 9. Las raíces digitales de
-- dichas sucesiones son
--    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 1)
--    [1,2,4,8,7,5,1,2,4,8,7,5,1,2,4,8,7,5,1,2]
--    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 3)
--    [3,6,3,6,3,6,3,6,3,6,3,6,3,6,3,6,3,6,3,6]
--    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 5)
--    [5,1,2,4,8,7,5,1,2,4,8,7,5,1,2,4,8,7,5,1]
--    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 7)
--    [7,5,1,2,4,8,7,5,1,2,4,8,7,5,1,2,4,8,7,5]
--    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 9)
--    [9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9]
-- Se observa que todas son periódicas.
 
raicesDigitalesSucesionRaicesDigitales2 :: Integer -> [Integer]
raicesDigitalesSucesionRaicesDigitales2 a =
  cycle (d : takeWhile (/= d) (tail (raicesDigitalesSucesionRaicesDigitales a)))
  where d = raizDigital a
 
-- 3ª solución
-- ===========
 
raicesDigitalesSucesionRaicesDigitales3 :: Integer -> [Integer]
raicesDigitalesSucesionRaicesDigitales3 a =
  case (raizDigital a) of
    1 -> cycle [1,2,4,8,7,5]
    2 -> cycle [2,4,8,7,5,1]
    3 -> cycle [3,6]
    4 -> cycle [4,8,7,5,1,2]
    5 -> cycle [5,1,2,4,8,7]
    6 -> cycle [6,3]
    7 -> cycle [7,5,1,2,4,8]
    8 -> cycle [8,7,5,1,2,4]
    9 -> cycle [9]
 
-- Comparación de eficiencia
-- =========================
 
-- La comparación es
--    λ> raicesDigitalesSucesionRaicesDigitales (9^100) !! (3*10^6)
--    9
--    (4.23 secs, 2,160,860,128 bytes)
--    λ> raicesDigitalesSucesionRaicesDigitales2 (9^100) !! (3*10^6)
--    9
--    (0.02 secs, 103,768 bytes)
--    λ> raicesDigitalesSucesionRaicesDigitales3 (9^100) !! (3*10^6)
--    9
--    (0.02 secs, 103,056 bytes)
--
--    λ> raicesDigitalesSucesionRaicesDigitales2 (9^100) !! (10^9)
--    9
--    (2.09 secs, 103,608 bytes)
--    λ> raicesDigitalesSucesionRaicesDigitales3 (9^100) !! (10^9)
--    9
--    (2.25 secs, 102,952 bytes)

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

5 soluciones de “Raíces digitales de sucesiones de raíces digitales

  1. Rubén Muñoz Mkrtchian
    -- 1ª Definición:
    -- =============
     
    raicesDigitalesSucesionRaicesDigitales :: Integer -> [Integer]
    raicesDigitalesSucesionRaicesDigitales n = map raizDigital (sucesionDefinidaPor n)
     
    -- sucesionDefinidaPor n es la sucesión de raíces digitales que comienza por el
    -- número n y se construye tal y como se explica en el enunciado. Por ejemplo,
    --    λ> take 20 (sucesionDefinidaPor 1)
    --    [1,2,4,8,16,23,28,29,31,35,43,50,55,56,58,62,70,77,82,83]
     
    sucesionDefinidaPor :: Integer -> [Integer]
    sucesionDefinidaPor n = iterate f n
      where f x = x + raizDigital x
     
    raizDigital :: Integer -> Integer
    raizDigital 0 = 0
    raizDigital n
      | k == 0    = 9
      | otherwise = k
          where k = mod n 9
     
    -- 2ª Definición:
    -- =============
    -- 
    -- Veamos que tan solo hay "tres" tipos de listas que podemos obtener al
    -- aplicar a raíz digital a las sucesiones de raíces digitales de cualquier
    -- número.
    --    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 1)
    --    [1,2,4,8,7,5,1,2,4,8,7,5,1,2,4,8,7,5,1,2]
    --    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 2)
    --    [2,4,8,7,5,1,2,4,8,7,5,1,2,4,8,7,5,1,2,4]
    --    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 3)
    --    [3,6,3,6,3,6,3,6,3,6,3,6,3,6,3,6,3,6,3,6]
    --    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 5)
    --    [5,1,2,4,8,7,5,1,2,4,8,7,5,1,2,4,8,7,5,1]
    --    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 9)
    --    [9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9]
    --
    -- No sobrecargo la solución aplicando esto anterior a todos los números
    -- menores que 10, pero queda claro que en función de cuál sea la raíz digital
    -- del número con el que empecemos, obtendremos "tres" listas posibles.
     
    raicesDigitalesSucesionRaicesDigitales2 :: Integer -> [Integer]
    raicesDigitalesSucesionRaicesDigitales2 n
      | raiz == 1 = cycle [1,2,4,8,7,5]
      | raiz == 2 = cycle [2,4,8,7,5,1]
      | raiz == 3 = cycle [3,6]
      | raiz == 4 = cycle [4,8,7,5,1,2]
      | raiz == 5 = cycle [5,1,2,4,8,7]
      | raiz == 6 = cycle [6,3]
      | raiz == 7 = cycle [7,5,1,2,4,8]
      | raiz == 8 = cycle [8,7,5,1,2,4]
      | raiz == 9 = repeat 9
          where raiz = raizDigital n
     
    -- Equivalencia de las definiciones:
    -- ================================
     
    prop :: Integer -> Int -> Bool
    prop m n = take n' (raicesDigitalesSucesionRaicesDigitales m') ==
               take n' (raicesDigitalesSucesionRaicesDigitales2 m')
                 where n' = abs n + 1
                       m' = abs m + 1
     
    -- Comparación de eficiencia:
    -- =========================
    --
    -- λ> raicesDigitalesSucesionRaicesDigitales (9^100) !! (10^6)
    -- 9
    -- (1.45 secs, 613,697,152 bytes)
    -- λ> raicesDigitalesSucesionRaicesDigitales2 (9^100) !! (10^6)
    -- 9
    -- (0.01 secs, 60,744 bytes)
    --
    -- λ> raicesDigitalesSucesionRaicesDigitales2 (9^100) !! (10^9)
    -- 9
    -- (1.28 secs, 61,096 bytes)
  2. Joaquín Infante Rodríguez
    import Data.List
     
    --Si hacemos una primera definición sin tener en cuenta ninguna propiedad ni
    --ningún patrón, sería la siguiente:
     
    digitos :: Integer -> [Integer]
    digitos n = [read [x] | x<-show n]
     
    raizDigital :: Integer -> Integer
    raizDigital n | length (digitos s) > 1 = raizDigital s
                   | otherwise = s
                  where s = sum (digitos n)
     
    sucesionDefinidaPor' :: Integer -> [Integer]
    sucesionDefinidaPor' n = iterate f n
      where f x = x + raizDigital x
     
    raicesDigitalesSucesionRaicesDigitales' :: Integer -> [Integer]
    raicesDigitalesSucesionRaicesDigitales' n = map (raizDigital) (sucesionDefinidaPor' n)
     
    --  Si calculamos ejemplos, vemos que en todas ellas existe un patrón que se
    --  repite, como máximo, cada 6 pasos:
    --  take 20 $raicesDigitalesSucesionRaicesDigitales' 1
    -- [1,2,4,8,7,5,1,2,4,8,7,5,1,2,4,8,7,5,1,2]
    -- (0.02 secs, 515,416 bytes)
    -- λ> take 20 $raicesDigitalesSucesionRaicesDigitales' 2
    -- [2,4,8,7,5,1,2,4,8,7,5,1,2,4,8,7,5,1,2,4]
    -- (0.00 secs, 537,312 bytes)
    -- λ> take 20 $raicesDigitalesSucesionRaicesDigitales' 3
    -- [3,6,3,6,3,6,3,6,3,6,3,6,3,6,3,6,3,6,3,6]
    -- (0.00 secs, 545,152 bytes)
    -- λ> take 20 $raicesDigitalesSucesionRaicesDigitales' 4
    -- [4,8,7,5,1,2,4,8,7,5,1,2,4,8,7,5,1,2,4,8]
    -- (0.00 secs, 564,504 bytes)
    -- λ> take 20 $raicesDigitalesSucesionRaicesDigitales' 5
    -- [5,1,2,4,8,7,5,1,2,4,8,7,5,1,2,4,8,7,5,1]
    -- (0.00 secs, 557,656 bytes)
     
    --Luego podemos definir las siguientes funciones:
     
    sucesionDefinidaPor :: Integer -> [Integer]
    sucesionDefinidaPor n = take 6 $iterate f n
      where f x = x + raizDigital x
     
    raicesDigitalesSucesionRaicesDigitales :: Integer -> [Integer]
    raicesDigitalesSucesionRaicesDigitales n = concat $repeat $nub $map (raizDigital) (sucesionDefinidaPor n)
     
    --Comparación de eficiencia:
     
    -- λ> raicesDigitalesSucesionRaicesDigitales' (9^100) !! (10^2)
    -- 9
    -- (0.05 secs, 40,178,064 bytes)
    -- λ> raicesDigitalesSucesionRaicesDigitales (9^100) !! (10^2)
    -- 9
    -- (0.02 secs, 4,412,008 bytes)
     
     
    -- λ> raicesDigitalesSucesionRaicesDigitales' (9^100) !! (10^3)
    -- 9
    -- (0.17 secs, 398,261,680 bytes)
    -- λ> raicesDigitalesSucesionRaicesDigitales (9^100) !! (10^3)
    -- 9
    -- (0.02 secs, 4,492,880 bytes)
     
     
    -- λ> raicesDigitalesSucesionRaicesDigitales' (9^100) !! (10^4)
    -- 9
    -- (1.60 secs, 3,978,740,168 bytes)
    -- raicesDigitalesSucesionRaicesDigitales (9^100) !! (10^4)
    -- 9
    -- (0.01 secs, 5,285,496 bytes)
     
    -- raicesDigitalesSucesionRaicesDigitales' (9^100) !! (10^8)
    -- Interrupted
    -- λ> raicesDigitalesSucesionRaicesDigitales (9^100) !! (10^8)
    -- 9
    -- (1.21 secs, 15,286,712 bytes)
     
     
    -- λ> raicesDigitalesSucesionRaicesDigitales' (9^100) !! (10^9)
    -- Interrupted
    -- λ> raicesDigitalesSucesionRaicesDigitales (9^100) !! (10^9)
    -- 9
    -- (8.34 secs, 88,004,405,344 bytes)
  3. Rubén Muñoz Mkrtchian
    -- 1ª Definición:
    -- =============
     
    raicesDigitalesSucesionRaicesDigitales :: Integer -> [Integer]
    raicesDigitalesSucesionRaicesDigitales n = map raizDigital (sucesionDefinidaPor n)
     
    -- sucesionDefinidaPor n es la sucesión de raíces digitales que comienza por el
    -- número n y se construye tal y como se explica en el enunciado. Por ejemplo,
    --    λ> take 20 (sucesionDefinidaPor 1)
    --    [1,2,4,8,16,23,28,29,31,35,43,50,55,56,58,62,70,77,82,83]
     
    sucesionDefinidaPor :: Integer -> [Integer]
    sucesionDefinidaPor n = iterate f n
      where f x = x + raizDigital x
     
    raizDigital :: Integer -> Integer
    raizDigital 0 = 0
    raizDigital n
      | k == 0    = 9
      | otherwise = k
          where k = mod n 9
     
    -- 2ª Definición:
    -- =============
    -- 
    -- Veamos que tan solo hay "tres" tipos de listas que podemos obtener al
    -- aplicar la raíz digital a las sucesiones de raíces digitales de cualquier
    -- número.
    --    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 1)
    --    [1,2,4,8,7,5,1,2,4,8,7,5,1,2,4,8,7,5,1,2]
    --    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 2)
    --    [2,4,8,7,5,1,2,4,8,7,5,1,2,4,8,7,5,1,2,4]
    --    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 3)
    --    [3,6,3,6,3,6,3,6,3,6,3,6,3,6,3,6,3,6,3,6]
    --    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 5)
    --    [5,1,2,4,8,7,5,1,2,4,8,7,5,1,2,4,8,7,5,1]
    --    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 9)
    --    [9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9]
    --
    -- No sobrecargo la solución aplicando esto anterior a todos los números
    -- menores que 10, pero queda claro que en función de cuál sea la raíz digital
    -- del número con el que empecemos, obtendremos "tres" listas posibles.
     
    raicesDigitalesSucesionRaicesDigitales2 :: Integer -> [Integer]
    raicesDigitalesSucesionRaicesDigitales2 n
      | raiz == 1 = cycle [1,2,4,8,7,5]
      | raiz == 2 = cycle [2,4,8,7,5,1]
      | raiz == 3 = cycle [3,6]
      | raiz == 4 = cycle [4,8,7,5,1,2]
      | raiz == 5 = cycle [5,1,2,4,8,7]
      | raiz == 6 = cycle [6,3]
      | raiz == 7 = cycle [7,5,1,2,4,8]
      | raiz == 8 = cycle [8,7,5,1,2,4]
      | raiz == 9 = repeat 9
          where raiz = raizDigital n
     
    -- Equivalencia de las definiciones:
    -- ================================
     
    prop :: Integer -> Int -> Bool
    prop m n = take n' (raicesDigitalesSucesionRaicesDigitales m') ==
               take n' (raicesDigitalesSucesionRaicesDigitales2 m')
                 where n' = abs n + 1
                       m' = abs m + 1
     
    -- Comparación de eficiencia:
    -- =========================
    --
    -- λ> raicesDigitalesSucesionRaicesDigitales (9^100) !! (10^6)
    -- 9
    -- (1.45 secs, 613,697,152 bytes)
    -- λ> raicesDigitalesSucesionRaicesDigitales2 (9^100) !! (10^6)
    -- 9
    -- (0.01 secs, 60,744 bytes)
    --
    -- λ> raicesDigitalesSucesionRaicesDigitales2 (9^100) !! (10^9)
    -- 9
    -- (1.28 secs, 61,096 bytes)
  4. Rubén Muñoz Mkrtchian
    -- 1ª Definición:
    -- =============
     
    raicesDigitalesSucesionRaicesDigitales :: Integer -> [Integer]
    raicesDigitalesSucesionRaicesDigitales n = map raizDigital (sucesionDefinidaPor n)
     
    -- sucesionDefinidaPor n es la sucesión de raíces digitales que comienza por el
    -- número n y se construye tal y como se explica en el enunciado. Por ejemplo,
    --    λ> take 20 (sucesionDefinidaPor 1)
    --    [1,2,4,8,16,23,28,29,31,35,43,50,55,56,58,62,70,77,82,83]
     
    sucesionDefinidaPor :: Integer -> [Integer]
    sucesionDefinidaPor n = iterate f n
      where f x = x + raizDigital x
     
    raizDigital :: Integer -> Integer
    raizDigital 0 = 0
    raizDigital n
      | k == 0    = 9
      | otherwise = k
          where k = mod n 9
     
    -- 2ª Definición:
    -- =============
    -- 
    -- Veamos que tan solo hay "tres" tipos de listas que podemos obtener al
    -- aplicar la raíz digital a las sucesiones de raíces digitales de cualquier
    -- número.
    --    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 1)
    --    [1,2,4,8,7,5,1,2,4,8,7,5,1,2,4,8,7,5,1,2]
    --    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 2)
    --    [2,4,8,7,5,1,2,4,8,7,5,1,2,4,8,7,5,1,2,4]
    --    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 3)
    --    [3,6,3,6,3,6,3,6,3,6,3,6,3,6,3,6,3,6,3,6]
    --    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 5)
    --    [5,1,2,4,8,7,5,1,2,4,8,7,5,1,2,4,8,7,5,1]
    --    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 9)
    --    [9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9]
    --
    -- No sobrecargo la solución aplicando esto anterior a todos los números
    -- menores que 10, pero queda claro que en función de cuál sea la raíz digital
    -- del número con el que empecemos, obtendremos "tres" listas posibles.
     
    raicesDigitalesSucesionRaicesDigitales2 :: Integer -> [Integer]
    raicesDigitalesSucesionRaicesDigitales2 n
      | raiz == 1 = cycle [1,2,4,8,7,5]
      | raiz == 2 = cycle [2,4,8,7,5,1]
      | raiz == 3 = cycle [3,6]
      | raiz == 4 = cycle [4,8,7,5,1,2]
      | raiz == 5 = cycle [5,1,2,4,8,7]
      | raiz == 6 = cycle [6,3]
      | raiz == 7 = cycle [7,5,1,2,4,8]
      | raiz == 8 = cycle [8,7,5,1,2,4]
      | raiz == 9 = repeat 9
          where raiz = raizDigital n
     
    -- Equivalencia de las definiciones:
    -- ================================
     
    prop :: Integer -> Int -> Bool
    prop m n = take n' (raicesDigitalesSucesionRaicesDigitales m') ==
               take n' (raicesDigitalesSucesionRaicesDigitales2 m')
                 where n' = abs n + 1
                       m' = abs m + 1
     
    -- Comparación de eficiencia:
    -- =========================
    --
    -- λ> raicesDigitalesSucesionRaicesDigitales (9^100) !! (10^6)
    -- 9
    -- (1.45 secs, 613,697,152 bytes)
    -- λ> raicesDigitalesSucesionRaicesDigitales2 (9^100) !! (10^6)
    -- 9
    -- (0.01 secs, 60,744 bytes)
    --
    -- λ> raicesDigitalesSucesionRaicesDigitales2 (9^100) !! (10^9)
    -- 9
    -- (1.27 secs, 61,096 bytes)
  5. Rubén Muñoz Mkrtchian
    -- 1ª Definición:
    -- =============
     
    raicesDigitalesSucesionRaicesDigitales :: Integer -> [Integer]
    raicesDigitalesSucesionRaicesDigitales n = map raizDigital (sucesionDefinidaPor n)
     
    -- sucesionDefinidaPor n es la sucesión de raíces digitales que comienza por el
    -- número n y se construye tal y como se explica en el enunciado. Por ejemplo,
    --    λ> take 20 (sucesionDefinidaPor 1)
    --    [1,2,4,8,16,23,28,29,31,35,43,50,55,56,58,62,70,77,82,83]
     
    sucesionDefinidaPor :: Integer -> [Integer]
    sucesionDefinidaPor n = iterate f n
      where f x = x + raizDigital x
     
    raizDigital :: Integer -> Integer
    raizDigital 0 = 0
    raizDigital n
      | k == 0    = 9
      | otherwise = k
          where k = mod n 9
     
    -- 2ª Definición:
    -- =============
    -- 
    -- Veamos que tan solo hay "tres" tipos de listas que podemos obtener al
    -- aplicar la raíz digital a las sucesiones de raíces digitales de cualquier
    -- número.
    --    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 1)
    --    [1,2,4,8,7,5,1,2,4,8,7,5,1,2,4,8,7,5,1,2]
    --    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 2)
    --    [2,4,8,7,5,1,2,4,8,7,5,1,2,4,8,7,5,1,2,4]
    --    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 3)
    --    [3,6,3,6,3,6,3,6,3,6,3,6,3,6,3,6,3,6,3,6]
    --    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 5)
    --    [5,1,2,4,8,7,5,1,2,4,8,7,5,1,2,4,8,7,5,1]
    --    λ> take 20 (raicesDigitalesSucesionRaicesDigitales 9)
    --    [9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9]
    --
    -- No sobrecargo la solución aplicando esto anterior a todos los números
    -- menores que 10, pero queda claro que en función de cuál sea la raíz digital
    -- del número con el que empecemos, obtendremos "tres" listas posibles.
     
    raicesDigitalesSucesionRaicesDigitales2 :: Integer -> [Integer]
    raicesDigitalesSucesionRaicesDigitales2 n
      | raiz == 1 = cycle [1,2,4,8,7,5]
      | raiz == 2 = cycle [2,4,8,7,5,1]
      | raiz == 3 = cycle [3,6]
      | raiz == 4 = cycle [4,8,7,5,1,2]
      | raiz == 5 = cycle [5,1,2,4,8,7]
      | raiz == 6 = cycle [6,3]
      | raiz == 7 = cycle [7,5,1,2,4,8]
      | raiz == 8 = cycle [8,7,5,1,2,4]
      | raiz == 9 = repeat 9
          where raiz = raizDigital n
     
    -- Equivalencia de las definiciones:
    -- ================================
     
    prop :: Integer -> Int -> Bool
    prop m n = take n' (raicesDigitalesSucesionRaicesDigitales m') ==
               take n' (raicesDigitalesSucesionRaicesDigitales2 m')
                 where n' = abs n + 1
                       m' = abs m + 1
     
    -- Comparación de eficiencia:
    -- =========================
    --
    -- λ> raicesDigitalesSucesionRaicesDigitales (9^100) !! (10^6)
    -- 9
    -- (1.45 secs, 613,697,152 bytes)
    -- λ> raicesDigitalesSucesionRaicesDigitales2 (9^100) !! (10^6)
    -- 9
    -- (0.01 secs, 60,744 bytes)
    --
    -- λ> raicesDigitalesSucesionRaicesDigitales2 (9^100) !! (10^9)
    -- 9
    -- (1.29 secs, 61,096 bytes)

Leave a Reply

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