Menu Close

Listas equidigitales

José A. Alonso,

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

Inicial
, , , ,

15 soluciones de “Listas equidigitales”

  1. Responder
    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. Responder
    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. Responder
    berarcmat 
    equidigital :: [Int] -> Bool
equidigital xs = and [ length (show x) == length (show y) 
                     | x <- xs, y <- xs]
  4. Responder
    estvegest 
    equidigital :: [Int] -> Bool
equidigital (x:y:xs) = length (show x) == length (show y) && 
                       equidigital (y:xs)
equidigital _        = True
  5. Responder
    frahidzam 
    equidigital :: [Int] -> Bool
equidigital (x:y:xs) = length (show x) == length (show y)  && 
                       equidigital (y:xs)
equidigital _        = True
  6. Responder
    ireprirod 
    equidigital :: [Int] -> Bool
equidigital xs = and [y == head ys | y <- ys]
  where ys = [length (show x) | x <- xs]
  7. Responder
    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. Responder
    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. Responder
    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. Responder
    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. Responder
    lucsanand 
    equidigital :: [Int] -> Bool
equidigital []  = True
equidigital [x] = True
equidigital (x:xs)
  | length (show (head xs)) == length (show x) = equidigital xs
  | otherwise                                  = False
  12. Responder
    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 )
    • Responder
      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. Responder
    jaibohbar 
    equidigital :: [Int] -> Bool
equidigital [] = True
equidigital xs = and [length (show x) == length (show y) | x <- xs, y <- xs]
  14. Responder
    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.