Menu Close

Subnúmeros pares

Los subnúmeros de un número x son los números que se pueden formar con dígitos de x en posiciones consecutivas. Por ejemplo, el número 254 tiene 6 subnúmeros: 2, 5, 4, 25, 54 y 254.

Definir las funciones

   subnumeros       :: Integer -> [Integer]
   nSubnumerosPares :: Integer -> Integer

tales que

  • (subnumerosPares x) es la lista de los subnúmeros pares de x. Por ejemplo,
     subnumerosPares 254   ==  [2,254,54,4]
     subnumerosPares 154   ==  [154,54,4]
     subnumerosPares 15    ==  []
  • (nSubnumerosPares x) es la cantidad de subnúmeros pares de x. Por ejemplo,
     nSubnumerosPares 254   ==  4
     nSubnumerosPares2 (4^(10^6))  ==  90625258498

Soluciones

import Data.List ( genericLength
                 , inits
                 , tails
                 )
 
subnumerosPares :: Integer -> [Integer]
subnumerosPares n =
  filter even (subnumeros n)
 
-- (subnumeros n) es la lista de los subnúmeros de n. Por ejemplo,
--    subnumeros 254  ==  [2,25,5,254,54,4]
subnumeros :: Integer -> [Integer]
subnumeros n =
  [read x | x <- sublistas (show n)]
 
-- (sublistas xs) es la lista de las sublistas de xs. Por ejemplo, 
--    sublistas "abc"  ==  ["a","ab","b","abc","bc","c"]
sublistas :: [a] -> [[a]]
sublistas xs =
  concat [init (tails ys) | ys <- tail (inits xs)]
 
-- 1ª definición
-- =============
 
nSubnumerosPares :: Integer -> Integer
nSubnumerosPares =
  genericLength . subnumerosPares
 
-- 2ª definición
-- =============
 
nSubnumerosPares2 :: Integer -> Integer
nSubnumerosPares2 =
  sum . posicionesDigitosPares 
 
-- (posicionesDigitosPares x) es la lista de las posiciones de los
-- dígitos pares de x. Por ejemplo,
--    posicionesDigitosPares 254  ==  [1,3]
posicionesDigitosPares :: Integer -> [Integer]
posicionesDigitosPares x =
  [n | (n,y) <- zip [1..] (show x)
     , y `elem` "02468"]
 
-- Comparación de eficiencia
--    λ> nSubnumerosPares (2^(10^3))
--    22934
--    (2.83 secs, 3,413,414,872 bytes)
--    λ> nSubnumerosPares2 (2^(10^3))
--    22934
--    (0.01 secs, 0 bytes)

5 soluciones de “Subnúmeros pares

  1. enrnarbej
    import Data.List
    import Data.Char
     
    subnumerosPares :: Integer -> [Integer]
    subnumerosPares =  filter even . map read . subConsecutivos . show 
     
    subConsecutivos :: String -> [String]
    subConsecutivos []     = []
    subConsecutivos (x:xs) = scanl (x y -> x ++ [y]) [x] xs ++ subConsecutivos xs 
     
    nSubnumerosPares :: Integer -> Integer
    nSubnumerosPares = genericLength . subnumerosPares
     
    nSubnumerosPares2 :: Integer -> Integer
    nSubnumerosPares2 = sum . map fst . filter (even . snd) . zip [1..] . map digitToInt .  show
  2. alvfercen
    import Data.List
    subnumerosPares :: Integer -> [Integer]
    subnumerosPares x = filter (even) (subnumeros x)
     
    nSubnumerosPares :: Integer -> Integer
    nSubnumerosPares = genericLength.subnumerosPares
     
    digitos :: Integer -> [Integer]
    digitos x = [read [n] |n <- show x]
     
    subnumeros :: Integer -> [Integer]
    subnumeros x = map digitToNumber (pepa (digitos x))
     
    pepa [x] = [[x]]
    pepa (x:xs) = [take n (x:xs) | n <- [1..length (x:xs)]] ++ pepa xs
     
    digitToNumber [] = 0
    digitToNumber [0] = 0
    digitToNumber (x:xs) = x*10^(length(x:xs)-1)+(digitToNumber xs)
  3. albcercid
    import Data.Char
     
     
    subnumerosPares :: Integer -> [Integer]
    subnumerosPares x = map read $ concat $ aux [] (show x)
        where aux _ [] = []
              aux xs (y:ys) | even (digitToInt y) = (f (reverse xs) y):aux (y:xs) ys
                            | otherwise = aux (y:xs) ys
              f [] t = [[t]]
              f p@(c:cs) t = (p++[t]):f cs t
     
    nSubnumerosPares :: Integer -> Integer
    nSubnumerosPares x = aux (show x) 1
          where aux [] _ = 0
                aux (y:ys) n | even (digitToInt y) = n + aux ys (n+1)
                             | otherwise = aux ys (n+1)
  4. manruiber
    f :: Integer -> [Integer]
    f x = [read [n] | n <- show x]
     
    c :: [String] -> [String]
    c [] = []
    c xs |length xs == 1 = []
         |otherwise = concat (take 2 xs) : c(drop 1 xs)
     
    subnumeros :: Integer -> [Integer]
    subnumeros x = map (read) (show x : (c z) ++ z)
      where z = map show (f x)
     
    subnumerosPares :: Integer -> [Integer]
    subnumerosPares x = filter (even) (subnumeros x)
     
    nSubnumerosPares :: Integer -> Integer
    nSubnumerosPares = genericLength.subnumerosPares
  5. marjimcom
    import Data.List
     
    subnumerosPares :: Integer -> [Integer]
    subnumerosPares x = filter (even) (map (read) (subConsecutivo xs))
     where
      xs = show x
     
     
    subConsecutivo (x:xs) = filter (/=[]) (nub (aux (x:xs)))
     where aux [] = [[]]
           aux (x:xs) = inits (x:xs) ++ aux xs
     
     
    nSubnumerosPares :: Integer -> Integer
    nSubnumerosPares = genericLength.subnumerosPares

Escribe tu solución

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