I1M2013: Ejercicios de evaluación perezosa y listas infinitas en Haskell
En segunda parte de la clase de hoy de Informática de 1º del Grado en Matemáticas hemos comentando las soluciones de los tres primeros ejercicios de evaluación perezosa y listas infinitas de la relación 15.
Los ejercicios, y sus soluciones, se muestran a continuación.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 |
-- --------------------------------------------------------------------- -- Ejercicio 1.1. Definir, por recursión, la función -- repite :: a -> [a] -- tal que (repite x) es la lista infinita cuyos elementos son x. Por -- ejemplo, -- repite 5 == [5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,... -- take 3 (repite 5) == [5,5,5] -- Nota: La función repite es equivalente a la función repeat definida -- en el preludio de Haskell. -- --------------------------------------------------------------------- repite :: a -> [a] repite x = x : repite x -- --------------------------------------------------------------------- -- Ejercicio 1.2. Definir, por comprensión, la función -- repiteC :: a -> [a] -- tal que (repiteC x) es la lista infinita cuyos elementos son x. Por -- ejemplo, -- repiteC 5 == [5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,... -- take 3 (repiteC 5) == [5,5,5] -- Nota: La función repiteC es equivalente a la función repeat definida -- en el preludio de Haskell. -- --------------------------------------------------------------------- repiteC :: a -> [a] repiteC x = [x | _ <- [1..]] -- --------------------------------------------------------------------- -- Ejercicio 2.1. Definir, por recursión, la función -- repiteFinita :: Int-> a -> [a] -- tal que (repiteFinita n x) es la lista con n elementos iguales a -- x. Por ejemplo, -- repiteFinita 3 5 == [5,5,5] -- Nota: La función repiteFinita es equivalente a la función replicate -- definida en el preludio de Haskell. -- --------------------------------------------------------------------- repiteFinita :: Int -> a -> [a] repiteFinita 0 x = [] repiteFinita n x = x : repiteFinita (n-1) x -- --------------------------------------------------------------------- -- Ejercicio 2.2. Definir, por comprensión, la función -- repiteFinitaC :: Int-> a -> [a] -- tal que (repiteFinitaC n x) es la lista con n elementos iguales a -- x. Por ejemplo, -- repiteFinitaC 3 5 == [5,5,5] -- Nota: La función repiteFinitaC es equivalente a la función replicate -- definida en el preludio de Haskell. -- --------------------------------------------------------------------- repiteFinitaC :: Int -> a -> [a] repiteFinitaC n x = [x | _ <- [1..n]] -- --------------------------------------------------------------------- -- Ejercicio 2.3. Definir, usando repite, la función -- repiteFinita' :: Int-> a -> [a] -- tal que (repiteFinita' n x) es la lista con n elementos iguales a -- x. Por ejemplo, -- repiteFinita' 3 5 == [5,5,5] -- Nota: La función repiteFinita' es equivalente a la función replicate -- definida en el preludio de Haskell. -- --------------------------------------------------------------------- repiteFinita' :: Int -> a -> [a] repiteFinita' n x = take n (repite x) -- --------------------------------------------------------------------- -- Ejercicio 3.1. Definir, por comprensión, la función -- ecoC :: String -> String -- tal que (ecoC xs) es la cadena obtenida a partir de la cadena xs -- repitiendo cada elemento tantas veces como indica su posición: el -- primer elemento se repite 1 vez, el segundo 2 veces y así -- sucesivamente. Por ejemplo, -- ecoC "abcd" == "abbcccdddd" -- --------------------------------------------------------------------- ecoC :: String -> String ecoC xs = concat [replicate i x | (i,x) <- zip [1..] xs] -- --------------------------------------------------------------------- -- Ejercicio 3.2. Definir, por recursión, la función -- ecoR :: String -> String -- tal que (ecoR xs) es la cadena obtenida a partir de la cadena xs -- repitiendo cada elemento tantas veces como indica su posición: el -- primer elemento se repite 1 vez, el segundo 2 veces y así -- sucesivamente. Por ejemplo, -- ecoR "abcd" == "abbcccdddd" -- --------------------------------------------------------------------- ecoR :: String -> String ecoR xs = aux 1 xs where aux n [] = [] aux n (x:xs) = replicate n x ++ aux (n+1) xs |