Menu Close

Iguales al siguiente

Enunciado

-- Definir la función
--    igualesAlSiguiente :: Eq a => [a] -> [a]
-- tal que (igualesAlSiguiente xs) es la lista de los elementos de xs
-- que son iguales a su siguiente. Por ejemplo,
--    igualesAlSiguiente [1,2,2,2,3,3,4]  ==  [2,2,3]
--    igualesAlSiguiente [1..10]          ==  []

Soluciones

import Data.List (group)
 
-- 1ª definición (por comprensión):
igualesAlSiguiente :: Eq a => [a] -> [a]
igualesAlSiguiente xs =
    [x | (x,y) <- zip xs (tail xs), x == y]
 
-- 2ª definición (por recursión):
igualesAlSiguiente2 :: Eq a => [a] -> [a]
igualesAlSiguiente2 (x:y:zs) | x == y    = x : igualesAlSiguiente2 (y:zs)
                             | otherwise = igualesAlSiguiente2 (y:zs)
igualesAlSiguiente2 _                    = []
 
-- 3ª definición (con concat y comprensión):
igualesAlSiguiente3 :: Eq a => [a] -> [a]
igualesAlSiguiente3 xs = concat [ys | (_:ys) <- group xs]
 
-- 4ª definición (con concat y map):
igualesAlSiguiente4 :: Eq a => [a] -> [a]
igualesAlSiguiente4 xs = concat (map tail (group xs))

9 soluciones de “Iguales al siguiente

  1. abemarrui
    igualesAlSiguiente :: Eq a => [a] -> [a]
    igualesAlSiguiente xs = [x | (x,y) <- zip xs (tail xs), x == y]
  2. milsancar
    igualesAlSiguiente :: Eq a => [a] -> [a]
    igualesAlSiguiente []  = []
    igualesAlSiguiente [_] = []
    igualesAlSiguiente (x:y:ys) | x == y    = x : igualesAlSiguiente (y:ys)
                                | otherwise = igualesAlSiguiente (y:ys)
    • Abel Martín
      igualesAlSiguiente :: Eq a => [a] -> [a]
      igualesAlSiguiente (x:y:zs) | x == y    = x : igualesAlSiguiente (y:zs)
                                  | otherwise = igualesAlSiguiente (y:zs)
      igualesAlSiguiente _                    = []
  3. Verónica
    igualesAlSiguiente :: Eq a => [a] -> [a]
    igualesAlSiguiente [_] = []
    igualesAlSiguiente (x:y:xs) | x == y    = [x] ++ igualesAlSiguiente (y:xs)
                                | otherwise = igualesAlSiguiente (y:xs)
      • Abel Martín

        Se puede completar y simplificar como sigue

        igualesAlSiguiente :: Eq a => [a] -> [a]
        igualesAlSiguiente (x:y:zs) | x == y    = x : igualesAlSiguiente (y:zs)
                                    | otherwise = igualesAlSiguiente (y:zs)
        igualesAlSiguiente _                    = []
  4. Laura Prieto
    igualesAlSiguienteA :: Eq a => [a] -> [a]
    igualesAlSiguienteA xs = 
        concat [replicate ((length ys)-1) (head ys) | ys <- group xs]
      • Abel Martín

        Se puede simplificar como sigue

        igualesAlSiguiente :: Eq a => [a] -> [a]
        igualesAlSiguiente xs = concat [ys | (_:ys) <- group xs]

Leave a Reply

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