Menu Close

Listas equidigitales

Una lista de números naturales es equidigital si todos sus elementos tienen el mismo número de dígitos.

Definir la función

   equidigital :: [Int] -> Bool

tal que (equidigital xs) se verifica si xs es una lista equidigital. Por ejemplo,

   equidigital [343,225,777,943]   ==  True
   equidigital [343,225,777,94,3]  ==  False

Soluciones

-- 1ª definición
-- =============
 
equidigital :: [Int] -> Bool
equidigital xs = todosIguales (numerosDeDigitos xs)
 
-- (numerosDeDigitos xs) es la lista de los números de dígitos de
-- los elementos de xs. Por ejemplo, 
--    numerosDeDigitos [343,225,777,943]   ==  [3,3,3,3]
--    numerosDeDigitos [343,225,777,94,3]  ==  [3,3,3,2,1]
numerosDeDigitos :: [Int] -> [Int]
numerosDeDigitos xs = [numeroDeDigitos x | x <- xs]
 
-- (numeroDeDigitos x) es el número de dígitos de x. Por ejemplo,
--    numeroDeDigitos 475  ==  3
numeroDeDigitos :: Int -> Int
numeroDeDigitos x = length (show x)
 
-- (todosIguales xs) se verifica si todos los elementos de xs son
-- iguales. Por ejemplo,
--    todosIguales [3,3,3,3]    ==  True
--    todosIguales [3,3,3,2,1]  ==  False
todosIguales (x:y:zs) = x == y && todosIguales (y:zs)
todosIguales _        = True
 
-- 2ª definición
-- =============
 
equidigital2 :: [Int] -> Bool
equidigital2 []     = True
equidigital2 (x:xs) = and [numeroDeDigitos y == n | y <- xs]
    where n = numeroDeDigitos x
 
-- 3ª definición
-- =============
 
equidigital3 :: [Int] -> Bool
equidigital3 (x:y:zs) = numeroDeDigitos x == numeroDeDigitos y &&
                        equidigital3 (y:zs)
equidigital3 _        = True

Pensamiento

Se miente más de la cuenta
por falta de fantasía:
también la verdad se inventa.

Antonio Machado

15 soluciones de “Listas equidigitales

  1. Andrea Guerrero González
    equidigital :: [Int ] -> Bool
    equidigital []  = True
    equidigital [x] = True
    equidigital (x:y:xs) | numDig x == numDig y = equidigital (y:xs)
                         | otherwise            = False
     
    numDig :: Int -> Int
    numDig n = length (show n)
  2. Luis Proenza Morgado
    equidigital :: [Int] -> Bool
    equidigital []     = True
    equidigital (x:xs) = and [ length (show x) == length (show (xs !! n) )
                             | n <- [0..length xs-1]]
  3. berarcmat
    equidigital :: [Int] -> Bool
    equidigital xs = and [ length (show x) == length (show y) 
                         | x <- xs, y <- xs]
  4. estvegest
    equidigital :: [Int] -> Bool
    equidigital (x:y:xs) = length (show x) == length (show y) && 
                           equidigital (y:xs)
    equidigital _        = True
  5. frahidzam
    equidigital :: [Int] -> Bool
    equidigital (x:y:xs) = length (show x) == length (show y)  && 
                           equidigital (y:xs)
    equidigital _        = True
  6. ireprirod
    equidigital :: [Int] -> Bool
    equidigital xs = and [y == head ys | y <- ys]
      where ys = [length (show x) | x <- xs]
  7. mansancab5
    equidigital :: [Int] -> Bool
    equidigital []  = True
    equidigital [x] = True
    equidigital (x:y:xs)
      | length (show x) == length (show y) = equidigital (y:xs)
      | otherwise                          = False
  8. pabreggar
    equidigital :: [Int] -> Bool
    equidigital xs = todosIguales [longitud x | x <- xs]
     
    todosIguales :: [Int] -> Bool
    todosIguales (x:y:xs) = x==y && todosIguales (y:xs)
    todosIguales _        = True
     
    longitud :: Int -> Int
    longitud n = sum [1 | _ <- show n]
  9. angruicam1

    Una primera solución más eficiente a la hora de tener que recorrer toda la lista, y una segunda que no tiene por qué recorrer toda la lista.

    import Data.List (groupBy)
     
    equidigital :: [Int] -> Bool
    equidigital =
      (<= 1)
      . length
      . groupBy (flip ((==) . length) . length)
      . map show
     
    equidigital' :: [Int] -> Bool
    equidigital' (x:xs) = aux (length (show x)) xs
      where aux x' (y:ys) = x' == y' && aux y' ys
              where y' = length (show y)
            aux _  _      = True
    equidigital' _      = True
     
    -- Comparación de la eficiencia:
    --
    -- λ> equidigital [1000000..9999999]
    -- True
    -- (3.71 secs, 5,904,085,992 bytes)
    -- λ> equidigital' [1000000..9999999]
    -- True
    -- (11.88 secs, 5,760,085,008 bytes)
    -- λ> equidigital [999999..9999999]
    -- False
    -- (3.75 secs, 5,904,086,200 bytes)
    -- λ> equidigital' [999999..9999999]
    -- False
    -- (0.00 secs, 86,280 bytes)
  10. aragon
    equidigital :: [Int] -> Bool
    equidigital xs = and [ length (digito1s x) == length (digito1s y)
                         | (x,y) <- zip xs (tail xs)]
     
    digito1s :: Int -> [Int]
    digito1s x = [read [n] | n <- show x]
  11. lucsanand
    equidigital :: [Int] -> Bool
    equidigital []  = True
    equidigital [x] = True
    equidigital (x:xs)
      | length (show (head xs)) == length (show x) = equidigital xs
      | otherwise                                  = False
  12. sermurgar
    equidigital :: [Int] -> Bool
    equidigital [] = True
    equidigital xs = and [longitud x == longitud y | x <- xs , y <- xs ]
     
    longitud :: Int -> Int
    longitud m | div m 10 == 0 = 1
               | div m 10 /= 0 = 1 + longitud (div m 10 )
    • fersancap

      La definición de sermurgar es muy ineficiente. Por ejemplo, comparada con la de ireprirod

      λ> equidigital1 (replicate 500 (10^6))
      True
      (2.74 secs, 1,474,203,008 bytes)
      λ> equidigital2 (replicate 500 (10^6))
      True
      (0.01 secs, 612,512 bytes)

      donde equidigital1 es la definición de sermurgar y equidigital2 es la definición de ireprirod .

  13. jaibohbar
    equidigital :: [Int] -> Bool
    equidigital [] = True
    equidigital xs = and [length (show x) == length (show y) | x <- xs, y <- xs]
  14. javmarcha1
    equidigital :: [Int] -> Bool
    equidigital [] = True
    equidigital (x:xs) =
      and [ length a == length b
          | (a,b) <- zip [show y | y <- xs] (repeat (show x))]

Escribe tu solución

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