Sucesión de Cantor de números innombrables

6 Comentarios

1. Haskell

   sucCantor :: [Integer] sucCantor = foldr (intercala) innombrables (replicate 100000 innombrables) innombrables :: [Integer] innombrables = map suc [1..] where suc n | n `mod` 7 == 0 || any (=='7') (show n) = 0 | otherwise = n intercala :: [Integer] -> [Integer] -> [Integer] intercala (x:xs) (y:ys) | x == 0 = y : intercala xs ys | otherwise = x : intercala xs (y:ys)

   1 2 3 4 5 6 7 8 9 10 11 12

   sucCantor :: [Integer] sucCantor = foldr (intercala) innombrables (replicate 100000 innombrables)                innombrables :: [Integer] innombrables = map suc [1..]              where               suc n | n `mod` 7 == 0 || any (=='7') (show n) = 0                     | otherwise = n   intercala :: [Integer] -> [Integer] -> [Integer] intercala (x:xs) (y:ys) | x == 0 = y : intercala xs ys                         | otherwise = x : intercala xs (y:ys)

   Responder

2. Haskell

   -- Una variante de la solución anterior. sucCantor :: [Integer] sucCantor = foldr1 aux (repeat innombrables) where aux (x:xs) ys = x:intercala xs ys esInnombrable :: Integer -> Bool esInnombrable x = rem x 7 == 0 || '7' `elem` show x innombrables :: [Integer] innombrables = map suc [1..] where suc n | esInnombrable n = 0 | otherwise = n intercala :: [Integer] -> [Integer] -> [Integer] intercala (x:xs) (y:ys) | x == 0 = y : intercala xs ys | otherwise = x : intercala xs (y:ys)

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

   -- Una variante de la solución anterior.   sucCantor :: [Integer] sucCantor = foldr1 aux (repeat innombrables)   where aux (x:xs) ys = x:intercala xs ys esInnombrable :: Integer -> Bool esInnombrable x = rem x 7 == 0 || '7' `elem` show x   innombrables :: [Integer] innombrables = map suc [1..]              where               suc n | esInnombrable n = 0                     | otherwise       = n intercala :: [Integer] -> [Integer] -> [Integer] intercala (x:xs) (y:ys) | x == 0 = y : intercala xs ys                         | otherwise = x : intercala xs (y:ys)

   Responder

3. Haskell

   sucCantor :: [Integer] sucCantor = 1:aux [2..] sucCantor 2 where aux (x:xs) (y:ys) 0 = y:aux xs ys 1 aux (x:xs) ys a | elem '7' (show x) = (head ys):aux xs (tail ys) (n a) | otherwise = x:aux xs ys (n a) n 6 = 0 n a = a+1

   1 2 3 4 5 6 7

   sucCantor :: [Integer] sucCantor = 1:aux [2..] sucCantor 2      where aux (x:xs) (y:ys) 0 = y:aux xs ys 1            aux (x:xs) ys a | elem '7' (show x) = (head ys):aux xs (tail ys) (n a)                            | otherwise = x:aux xs ys (n a)            n 6 = 0            n a = a+1

   Responder

4. Haskell

   sucCantor :: [Integer] sucCantor = 1 : construyeSucCantor [2..] sucCantor construyeSucCantor :: [Integer] -> [Integer] -> [Integer] construyeSucCantor [] _ = [] construyeSucCantor (x:xs) a@(y:ys) | '7' `elem` show x || x `mod` 7 == 0 = y : construyeSucCantor xs ys | otherwise = x : construyeSucCantor xs a

   1 2 3 4 5 6 7 8

   sucCantor :: [Integer] sucCantor = 1 : construyeSucCantor [2..] sucCantor   construyeSucCantor :: [Integer] -> [Integer] -> [Integer] construyeSucCantor [] _ = [] construyeSucCantor (x:xs) a@(y:ys)   | '7' `elem` show x || x `mod` 7 == 0 = y : construyeSucCantor xs ys   | otherwise                           = x : construyeSucCantor xs a

   Responder

5. (más eficiente usar Int)

   Haskell

   -- no hace siempre falta convertir todo el nº a cadena con7 :: Int ->Bool con7 n = case n `divMod` 10 of (_, 7) ->True (0, _) ->False (n, _) ->con7 n -- no hace falta dividir por 7 sucCantor :: [Int] sucCantor = 1: r 7 2 sucCantor where r !j !n bss@(b:bs) = let (i, j') = case j `compare` n of EQ ->(True, j + 7) GT ->(con7 n, j) in if i then b: r j' (n + 1) bs else n: r j' (n + 1) bss

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

   -- no hace siempre falta convertir todo el nº a cadena con7 :: Int ->Bool con7 n = case n `divMod` 10 of            (_, 7) ->True            (0, _) ->False            (n, _) ->con7 n   -- no hace falta dividir por 7 sucCantor :: [Int] sucCantor = 1: r 7 2 sucCantor   where r !j !n bss@(b:bs) = let (i, j') = case j `compare` n of                                              EQ ->(True, j + 7)                                              GT ->(con7 n, j)                              in if i                                   then b: r j' (n + 1) bs                                   else n: r j' (n + 1) bss

   Responder

6. Haskell

   digit n = [ read [x] | x <- show n] esCantor x | mod x 7 == 0 = True | elem 7 (digit x)= True | otherwise = False cant = [x | x<- [1..] , esCantor x ] f x | esCantor x =f(length (takeWhile (<x) cant)+1) | otherwise = x sucCantor = [ f x | x<- [1..]]

   1 2 3 4 5 6 7 8 9

   digit n = [ read [x] | x  <- show n] esCantor x | mod x 7 == 0 = True            | elem 7 (digit x)= True            | otherwise = False cant = [x | x<- [1..] , esCantor x ] f x | esCantor x =f(length (takeWhile (<x) cant)+1)     | otherwise = x   sucCantor = [ f x | x<- [1..]]

   Responder