I1M2010: Ejercicios de definiciones por plegado
En la clase de hoy de Informática de 1º del Grado en Matemáticas hemos comentado la resolución de ejercicios por plegado, resaltando el paso de las definiciones por recursión a las correspondientes definiciones por plegados. Los ejercicios comentados son el 11 y el 12 de la 11ª relación.
Los ejercicios y su solución 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 |
-- --------------------------------------------------------------------- -- Ejercicio 11. Se considera la función -- filtraAplica :: (a -> b) -> (a -> Bool) -> [a] -> [b] -- tal que (filtraAplica f p xs) es la lista obtenida aplicándole a los -- elementos de xs que cumplen el predicado p la función f. Por ejemplo, -- filtraAplica (4+) (<3) [1..7] => [5,6] -- Se pide, definir la función -- 1. por comprensión, -- 2. usando map y filter, -- 3. por recursión y -- 4. por plegado (con foldr). -- --------------------------------------------------------------------- -- La definición con lista de comprensión es filtraAplica_1 :: (a -> b) -> (a -> Bool) -> [a] -> [b] filtraAplica_1 f p xs = [f x | x <- xs, p x] -- La definición con map y filter es filtraAplica_2 :: (a -> b) -> (a -> Bool) -> [a] -> [b] filtraAplica_2 f p xs = map f (filter p xs) -- La definición por recursión es filtraAplica_3 :: (a -> b) -> (a -> Bool) -> [a] -> [b] filtraAplica_3 f p [] = [] filtraAplica_3 f p (x:xs) | p x = f x : filtraAplica_3 f p xs | otherwise = filtraAplica_3 f p xs -- La definición por plegado es filtraAplica_4 :: (a -> b) -> (a -> Bool) -> [a] -> [b] filtraAplica_4 f p = foldr g [] where g x y | p x = f x : y | otherwise = y -- La definición por plegado usando lambda es filtraAplica_4' :: (a -> b) -> (a -> Bool) -> [a] -> [b] filtraAplica_4' f p = foldr (\x y -> if p x then (f x : y) else y) [] -- --------------------------------------------------------------------- -- Ejercicio 12. Redefinir, usando foldr, la función concat. Por ejemplo, -- concat' [[1,3],[2,4,6],[1,9]] == [1,3,2,4,6,1,9] -- --------------------------------------------------------------------- -- La definición por recursión es concatR :: [[a]] -> [a] concatR [] = [] concatR (xs:xss) = xs ++ concatR xss -- La definición por plegado es concat' :: [[a]] -> [a] concat' = foldr (++) [] -- --------------------------------------------------------------------- -- Ejercicio 13. Redefinir, usando foldr, la función map. Por ejemplo, -- map' (+2) [1,7,3] == [3,9,5] -- --------------------------------------------------------------------- -- La definición por recursión es mapR :: (a -> b) -> [a] -> [b] mapR f [] = [] mapR f (x:xs) = f x : mapR f xs -- La definición por plegado es map' :: (a -> b) -> [a] -> [b] map' f = foldr g [] where g x xs = f x : xs -- La definición por plegado usando lambda es map'' :: (a -> b) -> [a] -> [b] map'' f = foldr (\x y -> f x:y) [] -- Otra definición es map''' :: (a -> b) -> [a] -> [b] map''' f = foldr ((:) . f) [] |