{"id":2506,"date":"2013-02-15T16:35:25","date_gmt":"2013-02-15T16:35:25","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=2506"},"modified":"2013-03-08T05:47:34","modified_gmt":"2013-03-08T05:47:34","slug":"i1m2012-funciones-de-orden-superior-4","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2012-funciones-de-orden-superior-4\/","title":{"rendered":"I1M2012: Funciones de orden superior (4)"},"content":{"rendered":"<p>En la clase de hoy de <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-12\">Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas<\/a> hemos comentando las soluciones de los ejercicios de la relaci\u00f3n <a href=\"https:\/\/www.glc.us.es\/~jalonso\/ejerciciosI1M2012G2\/images\/b\/b9\/Rel_15.hs\">15<\/a> (de funciones de orden superior). <\/p>\n<p>Los ejercicios, y sus soluciones, se muestran a continuaci\u00f3n.<br \/>\n<!--more--><\/p>\n<pre lang=\"haskell\">\r\n-- ---------------------------------------------------------------------\r\n-- Introducci\u00f3n                                                       --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- Esta relaci\u00f3n tiene contiene ejercicios con funciones de orden\r\n-- superior y definiciones por plegado correspondientes al tema 7 cuyas\r\n-- transparencias se encuentran en  \r\n--    http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-12\/temas\/tema-7.pdf\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Importaci\u00f3n de librer\u00edas auxiliares                                --\r\n-- ---------------------------------------------------------------------\r\n\r\nimport Data.List\r\nimport Test.QuickCheck\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.1. Definir, mediante recursi\u00f3n, la funci\u00f3n\r\n--    inversaR :: [a] -> [a]\r\n-- tal que (inversaR xs) es la inversa de la lista xs. Por ejemplo,\r\n--    inversaR [3,5,2,4,7]  ==  [7,4,2,5,3]\r\n-- ---------------------------------------------------------------------\r\n\r\ninversaR :: [a] -> [a]\r\ninversaR []     = []\r\ninversaR (x:xs) = (inversaR xs) ++ [x]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.2. Definir, mediante plegado, la funci\u00f3n\r\n--    inversaP :: [a] -> [a]\r\n-- tal que (inversaP xs) es la inversa de la lista xs. Por ejemplo,\r\n--    inversaP [3,5,2,4,7]  ==  [7,4,2,5,3]\r\n-- ---------------------------------------------------------------------\r\n\r\ninversaP :: [a] -> [a]\r\ninversaP = foldr f []\r\n    where f x y = y ++ [x]\r\n\r\n-- La definici\u00f3n anterior puede simplificarse a\r\ninversaP2 :: [a] -> [a]\r\ninversaP2 = foldr f []\r\n    where f x = (++ [x])\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.3. Definir, por recursi\u00f3n con acumulador, la funci\u00f3n\r\n--    inversaR' :: [a] -> [a]\r\n-- tal que (inversaR' xs) es la inversa de la lista xs. Por ejemplo,\r\n--    inversaR' [3,5,2,4,7]  ==  [7,4,2,5,3]\r\n-- ---------------------------------------------------------------------\r\n\r\ninversaR' :: [a] -> [a]\r\ninversaR' xs = inversaAux [] xs\r\n    where inversaAux ys []     = ys\r\n          inversaAux ys (x:xs) = inversaAux (x:ys) xs\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.4. La funci\u00f3n de plegado foldl est\u00e1 definida por\r\n--    foldl :: (a -> b -> a) -> a -> [b] -> a\r\n--    foldl f ys xs = aux ys xs\r\n--        where aux ys []     = ys\r\n--              aux ys (x:xs) = aux (f ys x) xs\r\n-- Definir, mediante plegado con foldl, la funci\u00f3n\r\n--    inversaP' :: [a] -> [a]\r\n-- tal que (inversaP' xs) es la inversa de la lista xs. Por ejemplo,\r\n--    inversaP' [3,5,2,4,7]  ==  [7,4,2,5,3]\r\n-- ---------------------------------------------------------------------\r\n\r\ninversaP' :: [a] -> [a]\r\ninversaP' = foldl f []\r\n    where f ys x = x:ys\r\n\r\n-- La definici\u00f3n anterior puede simplificarse lambda:\r\ninversaP'2 :: [a] -> [a]\r\ninversaP'2= foldl (\\ys x -> x:ys) []\r\n\r\n-- La definici\u00f3n puede simplificarse usando flip:\r\ninversaP'3 :: [a] -> [a]\r\ninversaP'3 = foldl (flip(:)) []\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.5. Comprobar con QuickCheck que las funciones reverse,\r\n-- inversaP e inversaP' son equivalentes.\r\n-- ---------------------------------------------------------------------\r\n\r\n-- La propiedad es\r\nprop_inversa :: Eq a => [a] -> Bool\r\nprop_inversa xs =\r\n    inversaP xs == ys &&\r\n    inversaP' xs == ys \r\n    where ys = reverse xs\r\n\r\n-- La comprobaci\u00f3n es\r\n--    ghci> quickCheck prop_inversa\r\n--    +++ OK, passed 100 tests.\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.6. Comparar la eficiencia de inversaP e inversaP'\r\n-- calculando el tiempo y el espacio que usado en evaluar las siguientes\r\n-- expresiones: \r\n--    head (inversaP [1..100000])\r\n--    head (inversaP' [1..100000])\r\n-- ---------------------------------------------------------------------\r\n\r\n-- La sesi\u00f3n es\r\n--    ghci> :set +s\r\n--    ghci> head (inversaP [1..100000])\r\n--    100000\r\n--    (0.41 secs, 20882460 bytes)\r\n--    ghci> head (inversaP' [1..100000])\r\n--    1\r\n--    (0.00 secs, 525148 bytes)\r\n--    ghci> :unset +s\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2.1. Definir, por recursi\u00f3n con acumulador, la funci\u00f3n\r\n--    dec2entR :: [Int] -> Int\r\n-- tal que (dec2entR xs) es el entero correspondiente a la expresi\u00f3n\r\n-- decimal xs. Por ejemplo,\r\n--    dec2entR [2,3,4,5]  ==  2345\r\n-- ---------------------------------------------------------------------\r\n\r\ndec2entR :: [Int] -> Int\r\ndec2entR xs = dec2entR' 0 xs\r\n    where dec2entR' a []     = a\r\n          dec2entR' a (x:xs) = dec2entR' (10*a+x) xs\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2.2. Definir, por plegado con foldl, la funci\u00f3n\r\n--    dec2entP :: [Int] -> Int\r\n-- tal que (dec2entP xs) es el entero correspondiente a la expresi\u00f3n\r\n-- decimal xs. Por ejemplo,\r\n--    dec2entP [2,3,4,5]  ==  2345\r\n-- ---------------------------------------------------------------------\r\n\r\ndec2entP :: [Int] -> Int\r\ndec2entP = foldl f 0\r\n    where f a x = 10*a+x\r\n\r\n-- La definici\u00f3n puede simplificarse usando lambda:\r\ndec2entP' :: [Int] -> Int\r\ndec2entP' = foldl (\\a x -> 10*a+x) 0\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 3.1. Definir por recursi\u00f3n la funci\u00f3n \r\n--    sumaR :: Num b => (a -> b) -> [a] -> b\r\n-- tal que (suma f xs) es la suma de los valores obtenido aplicando la\r\n-- funci\u00f3n f a lo elementos de la lista xs. Por ejemplo,\r\n--    sumaR (*2)  [3,5,10]  ==  36\r\n--    sumaR (\/10) [3,5,10]  ==  1.8\r\n -- ---------------------------------------------------------------------\r\n\r\nsumaR :: Num b => (a -> b) -> [a] -> b\r\nsumaR f []     = 0\r\nsumaR f (x:xs) = f x + sumaR f xs \r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 3.2. Definir por plegado la funci\u00f3n \r\n--    sumaP :: Num b => (a -> b) -> [a] -> b\r\n-- tal que (suma f xs) es la suma de los valores obtenido aplicando la\r\n-- funci\u00f3n f a lo elementos de la lista xs. Por ejemplo,\r\n--    sumaP (*2)  [3,5,10]  ==  36\r\n--    sumaP (\/10) [3,5,10]  ==  1.8\r\n-- ---------------------------------------------------------------------\r\n\r\nsumaP :: Num b => (a -> b) -> [a] -> b\r\nsumaP f = foldr (\\x y -> (f x) + y) 0\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 4.1. Redefinir, por recursi\u00f3n, la funci\u00f3n map. Por ejemplo,\r\n--    mapR (+2) [1,7,3]  ==  [3,9,5]\r\n-- ---------------------------------------------------------------------\r\n\r\nmapR :: (a -> b) -> [a] -> [b]\r\nmapR f [] = []\r\nmapR f (x:xs) = f x : mapR f xs\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 4.2. Redefinir, usando foldr, la funci\u00f3n map. Por ejemplo,\r\n--    mapP (+2) [1,7,3]  ==  [3,9,5]\r\n-- ---------------------------------------------------------------------\r\n\r\nmapP :: (a -> b) -> [a] -> [b]\r\nmapP f = foldr g []\r\n         where g x xs = f x : xs\r\n\r\n-- La definici\u00f3n por plegado usando lambda es\r\nmapP1 :: (a -> b) -> [a] -> [b]\r\nmapP1 f = foldr (\\x y -> f x:y) []\r\n\r\n-- Otra definici\u00f3n es\r\nmapP2 :: (a -> b) -> [a] -> [b]\r\nmapP2 f = foldr ((:) . f) []\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 5.1. Redefinir, usando foldr, la funci\u00f3n filter. Por\r\n-- ejemplo, \r\n--    filterR (<4) [1,7,3,2]  =>  [1,3,2]\r\n-- ---------------------------------------------------------------------\r\n\r\nfilterR :: (a -> Bool) -> [a] -> [a]\r\nfilterR p [] = []\r\nfilterR p (x:xs) | p x       = x : filterR p xs\r\n                 | otherwise = filterR p xs\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 5.2. Redefinir, usando foldr, la funci\u00f3n filter. Por\r\n-- ejemplo, \r\n--    filterP (<4) [1,7,3,2]  =>  [1,3,2]\r\n-- ---------------------------------------------------------------------\r\n\r\nfilterP :: (a -> Bool) -> [a] -> [a]\r\nfilterP p = foldr g []\r\n            where g x y | p x       = x:y \r\n                        | otherwise = y\r\n\r\n-- La definici\u00f3n por plegado y lambda es\r\nfilterP1 :: (a -> Bool) -> [a] -> [a]\r\nfilterP1 p = foldr (\\x y -> if (p x) then (x:y) else y) []\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 6.1. Definir, mediante recursi\u00f3n, la funci\u00f3n\r\n--    sumllR :: Num a => [[a]] -> a\r\n-- tal que (sumllR xss) es la suma de las sumas de las listas de xss. \r\n-- Por ejemplo, \r\n--    sumllR [[1,3],[2,5]]  ==  11\r\n-- ---------------------------------------------------------------------\r\n\r\nsumllR :: Num a => [[a]] -> a\r\nsumllR [] = 0\r\nsumllR (xs:xss) = sum xs + sumllR xss\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 6.2. Definir, mediante plegado, la funci\u00f3n\r\n--    sumllP :: Num a => [[a]] -> a\r\n-- tal que (sumllP xss) es la suma de las sumas de las listas de xss. Por\r\n-- ejemplo, \r\n--    sumllP [[1,3],[2,5]]  ==  11\r\n-- ---------------------------------------------------------------------\r\n\r\nsumllP :: Num a => [[a]] -> a\r\nsumllP = foldr f 0\r\n    where f xs n = sum xs + n\r\n\r\n-- La definici\u00f3n anterior puede simplificarse usando lambda\r\nsumllP' :: Num a => [[a]] -> a\r\nsumllP' = foldr (\\xs n -> sum xs + n) 0\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 6.3. Definir, mediante recursi\u00f3n con acumulador, la funci\u00f3n\r\n--    sumllA :: Num a => [[a]] -> a\r\n-- tal que (sumllA xss) es la suma de las sumas de las listas de xss. Por\r\n-- ejemplo, \r\n--    sumllA [[1,3],[2,5]]  ==  11\r\n-- ---------------------------------------------------------------------\r\n\r\nsumllA :: Num a => [[a]] -> a\r\nsumllA xs = aux 0 xs\r\n       where aux a [] = a       \r\n             aux a (xs:xss) = aux (a + sum xs) xss             \r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 6.4. Definir, mediante plegado con foldl, la funci\u00f3n\r\n--    sumllAP :: Num a => [[a]] -> a\r\n-- tal que (sumllAP xss) es la suma de las sumas de las listas de xss. Por\r\n-- ejemplo, \r\n--    sumllAP [[1,3],[2,5]]  ==  11\r\n-- ---------------------------------------------------------------------\r\n\r\nsumllAP :: Num a => [[a]] -> a\r\nsumllAP = foldl (\\a xs -> a + sum xs) 0\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 7.1. Definir, mediante recursi\u00f3n, la funci\u00f3n\r\n--    borraR :: Eq a => a -> a -> [a]\r\n-- tal que (borraR y xs) es la lista obtenida borrando las ocurrencias de\r\n-- y en xs. Por ejemplo, \r\n--    borraR 5 [2,3,5,6]    ==  [2,3,6]\r\n--    borraR 5 [2,3,5,6,5]  ==  [2,3,6]\r\n--    borraR 7 [2,3,5,6,5]  ==  [2,3,5,6,5]\r\n-- ---------------------------------------------------------------------\r\n\r\nborraR :: Eq a => a -> [a] -> [a]\r\nborraR z [] = []\r\nborraR z (x:xs) | z == x    = borraR z xs\r\n                | otherwise = x : borraR z xs\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 7.2. Definir, mediante plegado, la funci\u00f3n\r\n--    borraP :: Eq a => a -> a -> [a]\r\n-- tal que (borraP y xs) es la lista obtenida borrando las ocurrencias de\r\n-- y en xs. Por ejemplo, \r\n--    borraP 5 [2,3,5,6]    ==  [2,3,6]\r\n--    borraP 5 [2,3,5,6,5]  ==  [2,3,6]\r\n--    borraP 7 [2,3,5,6,5]  ==  [2,3,5,6,5]\r\n-- ---------------------------------------------------------------------\r\n\r\nborraP :: Eq a => a -> [a] -> [a]\r\nborraP z = foldr f []\r\n    where f x y | z == x    = y\r\n                | otherwise = x:y\r\n\r\n-- La definici\u00f3n por plegado con lambda es es\r\nborraP' :: Eq a => a -> [a] -> [a]\r\nborraP' z = foldr (\\x y -> if z==x then y else x:y) []\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 8.1. Definir, mediante recursi\u00f3n, la funci\u00f3n\r\n--    diferenciaR :: Eq a => [a] -> [a] -> [a]\r\n-- tal que (diferenciaR xs ys) es la diferencia del conjunto xs e ys; es\r\n-- decir el conjunto de los elementos de xs que no pertenecen a ys. Por\r\n-- ejemplo,  \r\n--    diferenciaR [2,3,5,6] [5,2,7]  ==  [3,6]\r\n-- ---------------------------------------------------------------------\r\n\r\ndiferenciaR :: Eq a => [a] -> [a] -> [a]\r\ndiferenciaR xs ys = aux xs xs ys\r\n    where aux a xs []     = a\r\n          aux a xs (y:ys) = aux (borraR y a) xs ys \r\n\r\n-- La definici\u00f3n, para aproximarse al patr\u00f3n foldr, se puede escribir como\r\ndiferenciaR' :: Eq a => [a] -> [a] -> [a]\r\ndiferenciaR' xs ys = aux xs xs ys\r\n    where aux a xs []     = a\r\n          aux a xs (y:ys) = aux (flip borraR a y) xs ys \r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 8.2. Definir, mediante plegado con foldl, la funci\u00f3n\r\n--    diferenciaP :: Eq a => [a] -> [a] -> [a]\r\n-- tal que (diferenciaP xs ys) es la diferencia del conjunto xs e ys; es\r\n-- decir el conjunto de los elementos de xs que no pertenecen a ys. Por\r\n-- ejemplo,  \r\n--    diferenciaP [2,3,5,6] [5,2,7]  ==  [3,6]\r\n-- ---------------------------------------------------------------------\r\n\r\ndiferenciaP :: Eq a => [a] -> [a] -> [a]\r\ndiferenciaP xs ys = foldl (flip borraR) xs ys\r\n\r\n-- La definici\u00f3n anterior puede simplificarse a\r\ndiferenciaP' :: Eq a => [a] -> [a] -> [a]\r\ndiferenciaP' = foldl (flip borraR)\r\n\r\n-- -------------------------------------------------------------------\r\n-- Ejercicio 9.1. Definir mediante plegado la funci\u00f3n \r\n--    producto :: Num a => [a] -> a\r\n-- tal que (producto xs) es el producto de los elementos de la lista\r\n-- xs. Por ejemplo, \r\n--    producto [2,1,-3,4,5,-6] == 720\r\n-- ---------------------------------------------------------------------\r\n\r\nproducto :: Num a => [a] -> a\r\nproducto = foldr (*) 1\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 9.2. Definir mediante plegado la funci\u00f3n \r\n--    productoPred :: Num a => (a -> Bool) -> [a] -> a\r\n-- tal que (productoPred p xs) es el producto de los elementos de la\r\n-- lista xs que verifican el predicado p. Por ejemplo, \r\n--    productoPred even [2,1,-3,4,-5,6] == 48\r\n-- ---------------------------------------------------------------------\r\n\r\nproductoPred :: Num a => (a -> Bool) -> [a] -> a\r\nproductoPred p = foldr (\\x y -> if p x then x*y else y) 1\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 9.3. Definir la funci\u00f3n \r\n--    productoPos :: (Num a, Ord a) => [a] -> a\r\n-- tal que (productoPos xs) esel producto de los elementos estr\u00edctamente\r\n-- positivos de la lista xs. Por ejemplo,\r\n--    productoPos [2,1,-3,4,-5,6] == 48\r\n-- ---------------------------------------------------------------------\r\n\r\nproductoPos :: (Num a, Ord a) => [a] -> a\r\nproductoPos = productoPred (>0)\r\n\r\n-- -------------------------------------------------------------------\r\n-- Ejercicio 10.1. Se denomina cola de una lista xs a una sublista no\r\n-- vac\u00eda de xs formada por un elemento y los siguientes hasta el\r\n-- final. Por ejemplo, [3,4,5] es una cola de la lista [1,2,3,4,5]. \r\n-- \r\n-- Definir la funci\u00f3n \r\n--    colas :: [a] -> [[a]]\r\n-- tal que (colas xs) es la lista de las colas de la lista xs. Por \r\n-- ejemplo,  \r\n--    colas []        == [[]]\r\n--    colas [1,2]     == [[1,2],[2],[]]\r\n--    colas [4,1,2,5] == [[4,1,2,5],[1,2,5],[2,5],[5],[]]\r\n-- ---------------------------------------------------------------------\r\n\r\ncolas :: [a] -> [[a]]\r\ncolas []     = [[]]\r\ncolas (x:xs) = (x:xs) : colas xs\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 10.2. Comprobar con QuickCheck que las funciones colas y\r\n-- tails son equivalentes.\r\n-- ---------------------------------------------------------------------\r\n\r\n-- La propiedad es\r\nprop_colas :: [Int] -> Bool\r\nprop_colas xs = colas xs == tails xs\r\n\r\n-- La comprobaci\u00f3n es\r\n--    ghci> quickCheck prop_colas\r\n--    +++ OK, passed 100 tests.\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 10.3. Se denomina cabeza de una lista xs a una sublista no\r\n-- vac\u00eda de la formada por el primer elemento y los siguientes hasta uno\r\n-- dado. Por ejemplo, [1,2,3] es una cabeza de [1,2,3,4,5]. \r\n-- \r\n-- Definir, por recursi\u00f3n, la funci\u00f3n \r\n--    cabezas :: [a] -> [[a]]\r\n-- tal que (cabezas xs) es la lista de las cabezas de la lista xs. Por\r\n-- ejemplo, \r\n--    cabezas []          == [[]] \r\n--    cabezas [1,4]       == [[],[1],[1,4]] \r\n--    cabezas [1,4,5,2,3] == [[],[1],[1,4],[1,4,5],[1,4,5,2],[1,4,5,2,3]] \r\n-- ---------------------------------------------------------------------\r\n\r\ncabezas :: [a] -> [[a]]\r\ncabezas []     = [[]]\r\ncabezas (x:xs) = [] : [x:ys | ys <- cabezas xs]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 10.4. Definir, por plegado, la funci\u00f3n \r\n--    cabezasP :: [a] -> [[a]]\r\n-- tal que (cabezasP xs) es la lista de las cabezas de la lista xs. Por\r\n-- ejemplo, \r\n--    cabezasP []          == [[]] \r\n--    cabezasP [1,4]       == [[],[1],[1,4]] \r\n--    cabezasP [1,4,5,2,3] == [[],[1],[1,4],[1,4,5],[1,4,5,2],[1,4,5,2,3]] \r\n-- ---------------------------------------------------------------------\r\n\r\ncabezasP :: [a] -> [[a]]\r\ncabezasP = foldr (\\x y -> [x]:[x:ys | ys <- y]) []\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 10.5. Definir, mediantes funciones de orden superior, la \r\n-- funci\u00f3n  \r\n--    cabezasS :: [a] -> [[a]]\r\n-- tal que (cabezasS xs) es la lista de las cabezas de la lista xs. Por\r\n-- ejemplo, \r\n--    cabezasS []          == [[]] \r\n--    cabezasS [1,4]       == [[],[1],[1,4]] \r\n--    cabezasS [1,4,5,2,3] == [[],[1],[1,4],[1,4,5],[1,4,5,2],[1,4,5,2,3]] \r\n-- ---------------------------------------------------------------------\r\n\r\ncabezasS :: [a] -> [[a]]\r\ncabezasS xs = reverse (map reverse (colas (reverse xs)))\r\n\r\n-- La anterior definici\u00f3n puede escribirse sin argumentos como \r\ncabezasS' :: [a] -> [[a]]\r\ncabezasS' = reverse . map reverse . (colas . reverse)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 10.6. Comprobar con QuickCheck que las funciones cabezas y\r\n-- inits son equivalentes.\r\n-- ---------------------------------------------------------------------\r\n\r\n-- La propiedad es\r\nprop_cabezas :: [Int] -> Bool\r\nprop_cabezas xs = cabezas xs == inits xs\r\n\r\n-- La comprobaci\u00f3n es\r\n--    ghci> quickCheck prop_cabezas\r\n--    +++ OK, passed 100 tests.\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"<p>En la clase de hoy de Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas hemos comentando las soluciones de los ejercicios de la relaci\u00f3n 15 (de funciones de orden superior). Los ejercicios, y sus soluciones, se muestran a continuaci\u00f3n.<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"_kad_post_transparent":"","_kad_post_title":"","_kad_post_layout":"","_kad_post_sidebar_id":"","_kad_post_content_style":"","_kad_post_vertical_padding":"","_kad_post_feature":"","_kad_post_feature_position":"","_kad_post_header":false,"_kad_post_footer":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"footnotes":"","_jetpack_memberships_contains_paid_content":false},"categories":[1],"tags":[298],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_likes_enabled":false,"_links":{"self":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/2506"}],"collection":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/comments?post=2506"}],"version-history":[{"count":5,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/2506\/revisions"}],"predecessor-version":[{"id":2692,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/2506\/revisions\/2692"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=2506"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=2506"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=2506"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}