{"id":4000,"date":"2014-01-10T17:23:16","date_gmt":"2014-01-10T16:23:16","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=4000"},"modified":"2014-01-14T17:24:36","modified_gmt":"2014-01-14T16:24:36","slug":"i1m2013-ejercicios-sobre-funciones-de-orden-superior-y-plegados-3","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2013-ejercicios-sobre-funciones-de-orden-superior-y-plegados-3\/","title":{"rendered":"I1M2013: Ejercicios sobre funciones de orden superior y plegados (3)"},"content":{"rendered":"<p>En la primera parte de la clase de hoy del curso <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-13\">Inform\u00e1tica (de 1\u00ba de Grado en Matem\u00e1ticas)<\/a> se han comentado las soluciones de los ejercicios de la 13\u00aa relaci\u00f3n. En los ejercicios se piden definiciones de funciones de orden superior y con plegados.<\/p>\n<p>Los ejercicios y soluciones se muestran a continuaci\u00f3n<br \/>\n<!--more--><\/p>\n<pre lang=\"haskell\">\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: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 primera parte de la clase de hoy del curso Inform\u00e1tica (de 1\u00ba de Grado en Matem\u00e1ticas) se han comentado las soluciones de los ejercicios de la 13\u00aa relaci\u00f3n. En los ejercicios se piden definiciones de funciones de orden superior y con plegados. Los ejercicios y soluciones se muestran a continuaci\u00f3n<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","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":[222],"tags":[270,300,126],"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\/4000"}],"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=4000"}],"version-history":[{"count":1,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/4000\/revisions"}],"predecessor-version":[{"id":4001,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/4000\/revisions\/4001"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=4000"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=4000"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=4000"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}