group

Sin consecutivos repetidos

PorJosé A. Alonso 9-diciembre-201427-diciembre-2014

Enunciado

-- Definir la función
--    sinConsecutivosRepetidos :: Eq a => [a] -> [a]
-- tal que (sinConsecutivosRepetidos xs) es la lista obtenida a partir
-- de xs de forma que si hay dos o más elementos idénticos consecutivos,
-- borra las repeticiones y deja sólo el primer elemento. Por ejemplo,
--    ghci> sinConsecutivosRepetidos "eesssooo essss   toodddooo"
--    "eso es todo"

-- Definir la función

-- sinConsecutivosRepetidos :: Eq a => [a] -> [a]

-- tal que (sinConsecutivosRepetidos xs) es la lista obtenida a partir

-- de xs de forma que si hay dos o más elementos idénticos consecutivos,

-- borra las repeticiones y deja sólo el primer elemento. Por ejemplo,

-- ghci> sinConsecutivosRepetidos "eesssooo essss toodddooo"

-- "eso es todo"

Soluciones

import Data.List (group)

-- 1ª solución (por comprensión):
sinConsecutivosRepetidos :: Eq a => [a] -> [a]
sinConsecutivosRepetidos xs = [x | (x:_) <- group xs]

-- 2ª solución (por recursión):
sinConsecutivosRepetidos2 :: Eq a => [a] -> [a]
sinConsecutivosRepetidos2 [] = []
sinConsecutivosRepetidos2 (x:xs) = 
    x : sinConsecutivosRepetidos2 (dropWhile (==x) xs)

import Data.List (group)

-- 1ª solución (por comprensión):

sinConsecutivosRepetidos :: Eq a => [a] -> [a]

sinConsecutivosRepetidos xs = [x | (x:_) <- group xs]

-- 2ª solución (por recursión):

sinConsecutivosRepetidos2 :: Eq a => [a] -> [a]

sinConsecutivosRepetidos2 [] = []

sinConsecutivosRepetidos2 (x:xs) =

x : sinConsecutivosRepetidos2 (dropWhile (==x) xs)

Llanuras de longitud dada

PorJosé A. Alonso 4-diciembre-20141-mayo-2016

Enunciado

-- Una llanura de longitud n de una lista xs es una sublista de xs
-- formada por n elementos iguales.
--
-- Definir la función
--    llanuras :: Eq a => Int -> [a] -> [[a]]
-- tal que (llanuras n xs) es la lista de las llanuras de xs que tienen
-- n elementos como mínimo. Por ejemplo,
--    llanuras 3 "aabbbcddddffxffxx"  ==  ["bbb","dddd"]

-- Una llanura de longitud n de una lista xs es una sublista de xs

-- formada por n elementos iguales.

-- Definir la función

-- llanuras :: Eq a => Int -> [a] -> [[a]]

-- tal que (llanuras n xs) es la lista de las llanuras de xs que tienen

-- n elementos como mínimo. Por ejemplo,

-- llanuras 3 "aabbbcddddffxffxx" == ["bbb","dddd"]

Soluciones

import Data.List (group)
import Test.QuickCheck

-- 1ª definición (por comprensión):
llanuras :: Eq a => Int -> [a] -> [[a]]
llanuras n xs = [ys | ys <- group xs, length ys >= n] 

-- 2ª definición (por recursión con takeWhile y dropWhile):
llanuras2 :: Eq a => Int -> [a] -> [[a]]
llanuras2 _ [] = []
llanuras2 n xs@(x:_) 
    | length ys >= n = ys : llanuras2 n (dropWhile (x==) xs) 
    | otherwise      = llanuras2 n (dropWhile (x==) xs) 
    where ys = takeWhile (x==) xs

-- 3ª definición (por recursión con span):
llanuras3 :: Eq a => Int -> [a] -> [[a]]
llanuras3 _ [] = []
llanuras3 n xs@(x:_) 
    | length ys >= n = ys : llanuras3 n zs
    | otherwise      = llanuras3 n zs
    where (ys,zs) = span (x==) xs

-- 4ª definición (por recursión con span):
llanuras4 :: Eq a => Int -> [a] -> [[a]]
llanuras4 n = aux where
    aux [] = []
    aux xs@(x:_) | length ys >= n = ys : llanuras4 n zs
                 | otherwise      = llanuras4 n zs
                 where (ys,zs) = span (x==) xs

-- ---------------------------------------------------------------------
-- § Verificación                                                     --
-- ---------------------------------------------------------------------

-- Las definiciones son equivalentes
prop_equivalencia :: Int -> [Int] -> Bool
prop_equivalencia n xs =
    llanuras2 n xs == ys &&
    llanuras3 n xs == ys
    where ys = llanuras n xs

-- La comprobación es
--    ghci> quickCheck prop_equivalencia
--    +++ OK, passed 100 tests.

import Data.List (group)

import Test.QuickCheck

-- 1ª definición (por comprensión):

llanuras :: Eq a => Int -> [a] -> [[a]]

llanuras n xs = [ys | ys <- group xs, length ys >= n]

-- 2ª definición (por recursión con takeWhile y dropWhile):

llanuras2 :: Eq a => Int -> [a] -> [[a]]

llanuras2 _ [] = []

llanuras2 n xs@(x:_)

| length ys >= n = ys : llanuras2 n (dropWhile (x==) xs)

| otherwise = llanuras2 n (dropWhile (x==) xs)

where ys = takeWhile (x==) xs

-- 3ª definición (por recursión con span):

llanuras3 :: Eq a => Int -> [a] -> [[a]]

llanuras3 _ [] = []

llanuras3 n xs@(x:_)

| length ys >= n = ys : llanuras3 n zs

| otherwise = llanuras3 n zs

where (ys,zs) = span (x==) xs

-- 4ª definición (por recursión con span):

llanuras4 :: Eq a => Int -> [a] -> [[a]]

llanuras4 n = aux where

aux [] = []

aux xs@(x:_) | length ys >= n = ys : llanuras4 n zs

| otherwise = llanuras4 n zs

where (ys,zs) = span (x==) xs

-- ---------------------------------------------------------------------

-- § Verificación --

-- ---------------------------------------------------------------------

-- Las definiciones son equivalentes

prop_equivalencia :: Int -> [Int] -> Bool

prop_equivalencia n xs =

llanuras2 n xs == ys &&

llanuras3 n xs == ys

where ys = llanuras n xs

-- La comprobación es

-- ghci> quickCheck prop_equivalencia

-- +++ OK, passed 100 tests.

Referencias

Esté ejercicio está basado en el problema Llanura de números iguales con longitud igual a n propuesto Solveet!

Entradas recientes

Buscar

Correo electrónico