{"id":6378,"date":"2018-11-23T21:18:32","date_gmt":"2018-11-23T20:18:32","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=6378"},"modified":"2018-11-24T11:19:24","modified_gmt":"2018-11-24T10:19:24","slug":"i1m2018-ejercicios-de-funciones-de-orden-superior","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2018-ejercicios-de-funciones-de-orden-superior\/","title":{"rendered":"I1M2018: Ejercicios de funciones de orden superior"},"content":{"rendered":"<p>En la segunda parte de la clase de hoy de <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-18\">Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas<\/a> hemos comentado las soluciones de los primeros ejercicios de la relaci\u00f3n 7 sobre funciones de orden superior.<\/p>\n<p>Los ejercicios y su soluci\u00f3n se muestran a continuaci\u00f3n<br \/>\n<!--more--><\/p>\n<pre lang=\"haskell\">\n-- ---------------------------------------------------------------------\n-- Introducci\u00f3n                                                       --\n-- ---------------------------------------------------------------------\n\n-- Esta relaci\u00f3n tiene contiene ejercicios con funciones de orden\n-- superior y definiciones por plegado correspondientes al tema 7 \n-- http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-18\/temas\/tema-7.html\n\n-- ---------------------------------------------------------------------\n-- Importaci\u00f3n de librer\u00edas auxiliares                                --\n-- ---------------------------------------------------------------------\n\nimport Test.QuickCheck\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 1. Definir la funci\u00f3n\n--    segmentos :: (a -> Bool) -> [a] -> [a]\n-- tal que (segmentos p xs) es la lista de los segmentos de xs cuyos\n-- elementos verifican la propiedad p. Por ejemplo,\n--    segmentos even [1,2,0,4,9,6,4,5,7,2]  ==  [[2,0,4],[6,4],[2]]\n--    segmentos odd  [1,2,0,4,9,6,4,5,7,2]  ==  [[1],[9],[5,7]]\n-- ---------------------------------------------------------------------\n\nsegmentos :: (a -> Bool) -> [a] -> [[a]]\nsegmentos _ [] = []\nsegmentos p (x:xs) \n    | p x       = takeWhile p (x:xs) : segmentos p (dropWhile p xs)\n    | otherwise = segmentos p xs\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 2.1. Definir, por comprensi\u00f3n, la funci\u00f3n\n--    relacionadosC :: (a -> a -> Bool) -> [a] -> Bool\n-- tal que (relacionadosC r xs) se verifica si para todo par (x,y) de\n-- elementos consecutivos de xs se cumple la relaci\u00f3n r. Por ejemplo,\n--    relacionadosC (<) [2,3,7,9]                ==  True\n--    relacionadosC (<) [2,3,1,9]                ==  False\n-- ---------------------------------------------------------------------\n\nrelacionadosC :: (a -> a -> Bool) -> [a] -> Bool\nrelacionadosC r xs = and [r x y | (x,y) <- zip xs (tail xs)]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 2.2. Definir, por recursi\u00f3n, la funci\u00f3n\n--    relacionadosR :: (a -> a -> Bool) -> [a] -> Bool\n-- tal que (relacionadosR r xs) se verifica si para todo par (x,y) de\n-- elementos consecutivos de xs se cumple la relaci\u00f3n r. Por ejemplo,\n--    relacionadosR (<) [2,3,7,9]                ==  True\n--    relacionadosR (<) [2,3,1,9]                ==  False\n-- ---------------------------------------------------------------------\n\nrelacionadosR :: (a -> a -> Bool) -> [a] -> Bool\nrelacionadosR r (x:y:zs) = r x y && relacionadosR r (y:zs)\nrelacionadosR _ _        = True\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 3.1. Definir la funci\u00f3n\n--    agrupa :: Eq a => [[a]] -> [[a]]\n-- tal que (agrupa xss) es la lista de las listas obtenidas agrupando\n-- los primeros elementos, los segundos, ... Por ejemplo, \n--    agrupa [[1..6],[7..9],[10..20]]  ==  [[1,7,10],[2,8,11],[3,9,12]]\n--    agrupa []                        ==  []\n-- ---------------------------------------------------------------------\n\nagrupa :: Eq a => [[a]] -> [[a]]\nagrupa []  = []\nagrupa xss\n    | [] `elem` xss = []\n    | otherwise     = primeros xss : agrupa (restos xss)\n    where primeros = map head\n          restos   = map tail\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 3.2. Comprobar con QuickChek que la longitud de todos los\n-- elementos de (agrupa xs) es igual a la longitud de xs.\n-- ---------------------------------------------------------------------\n\n-- La propiedad es\nprop_agrupa :: [[Int]] -> Bool\nprop_agrupa xss =\n    and [length xs == n | xs <- agrupa xss]\n    where n = length xss\n\n-- La comprobaci\u00f3n es\n--    ghci> quickCheck prop_agrupa\n--    +++ OK, passed 100 tests.\n\ncomprueba_agrupa :: IO ()\ncomprueba_agrupa =\n  quickCheck prop_agrupa\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 4.1. Definir, por recursi\u00f3n, la funci\u00f3n \n--    concatR :: [[a]] -> [a]\n-- tal que (concatR xss) es la concatenaci\u00f3n de las listas de xss. Por\n-- ejemplo, \n--    concatR [[1,3],[2,4,6],[1,9]]  ==  [1,3,2,4,6,1,9]\n-- ---------------------------------------------------------------------\n\nconcatR :: [[a]] -> [a]\nconcatR []       = []\nconcatR (xs:xss) = xs ++ concatR xss\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 4.2. Definir, usando foldr, la funci\u00f3n \n--    concatP :: [[a]] -> [a]\n-- tal que (concatP xss) es la concatenaci\u00f3n de las listas de xss. Por\n-- ejemplo, \n--    concatP [[1,3],[2,4,6],[1,9]]  ==  [1,3,2,4,6,1,9]\n-- ---------------------------------------------------------------------\n\nconcatP :: [[a]] -> [a]\nconcatP = foldr (++) []\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 4.3. Comprobar con QuickCheck que la funciones concatR,\n-- concatP y concat son equivalentes.\n-- ---------------------------------------------------------------------\n\n-- La propiedad es\nprop_concat :: [[Int]] -> Bool\nprop_concat xss =\n  concatR xss == ys && concatP xss == ys\n  where ys = concat xss\n\n-- La comprobaci\u00f3n es\n--    ghci> quickCheck prop_concat\n--    +++ OK, passed 100 tests.\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 4.4. Comprobar con QuickCheck que la longitud de \n-- (concatP xss) es la suma de las longitudes de los elementos de xss.\n-- ---------------------------------------------------------------------\n\n-- La propiedad es\nprop_longConcat :: [[Int]] -> Bool\nprop_longConcat xss =\n  length (concatP xss) == sum [length xs | xs <- xss]\n\n-- La comprobaci\u00f3n es\n--    ghci> quickCheck prop_longConcat\n--    +++ OK, passed 100 tests.\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 5.1. Definir, por comprensi\u00f3n, la funci\u00f3n\n--    filtraAplicaC :: (a -> b) -> (a -> Bool) -> [a] -> [b]\n-- tal que (filtraAplicaC f p xs) es la lista obtenida aplic\u00e1ndole a los\n-- elementos de xs que cumplen el predicado p la funci\u00f3n f. Por ejemplo,\n--    filtraAplicaC (4+) (<3) [1..7]  =>  [5,6]\n-- ---------------------------------------------------------------------\n\nfiltraAplicaC :: (a -> b) -> (a -> Bool) -> [a] -> [b]\nfiltraAplicaC f p xs = [f x | x <- xs, p x]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 5.2. Definir, usando map y filter, la funci\u00f3n\n--    filtraAplicaMF :: (a -> b) -> (a -> Bool) -> [a] -> [b]\n-- tal que (filtraAplicaMF f p xs) es la lista obtenida aplic\u00e1ndole a los\n-- elementos de xs que cumplen el predicado p la funci\u00f3n f. Por ejemplo,\n--    filtraAplicaMF (4+) (<3) [1..7]  =>  [5,6]\n-- ---------------------------------------------------------------------\n\nfiltraAplicaMF :: (a -> b) -> (a -> Bool) -> [a] -> [b]\nfiltraAplicaMF f p xs = map f (filter p xs)\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 5.3. Definir, por recursi\u00f3n, la funci\u00f3n\n--    filtraAplicaR :: (a -> b) -> (a -> Bool) -> [a] -> [b]\n-- tal que (filtraAplicaR f p xs) es la lista obtenida aplic\u00e1ndole a los\n-- elementos de xs que cumplen el predicado p la funci\u00f3n f. Por ejemplo,\n--    filtraAplicaR (4+) (<3) [1..7]  =>  [5,6]\n-- ---------------------------------------------------------------------\n\nfiltraAplicaR :: (a -> b) -> (a -> Bool) -> [a] -> [b]\nfiltraAplicaR _ _ [] = []\nfiltraAplicaR f p (x:xs) | p x       = f x : filtraAplicaR f p xs\n                         | otherwise = filtraAplicaR f p xs\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 5.4. Definir, por plegado, la funci\u00f3n\n--    filtraAplicaP :: (a -> b) -> (a -> Bool) -> [a] -> [b]\n-- tal que (filtraAplicaP f p xs) es la lista obtenida aplic\u00e1ndole a los\n-- elementos de xs que cumplen el predicado p la funci\u00f3n f. Por ejemplo,\n--    filtraAplicaP (4+) (<3) [1..7]  =>  [5,6]\n-- ---------------------------------------------------------------------\n\nfiltraAplicaP :: (a -> b) -> (a -> Bool) -> [a] -> [b]\nfiltraAplicaP f p = foldr g []\n    where g x y | p x       = f x : y\n                | otherwise = y\n\n-- La definici\u00f3n por plegado usando lambda es\nfiltraAplicaP2 :: (a -> b) -> (a -> Bool) -> [a] -> [b]\nfiltraAplicaP2 f p = \n    foldr (\\x y -> if p x then f x : y else y) []\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 6.1. Definir, mediante recursi\u00f3n, la funci\u00f3n\n--    maximumR :: Ord a => [a] -> a\n-- tal que (maximumR xs) es el m\u00e1ximo de la lista xs. Por ejemplo,\n--    maximumR [3,7,2,5]                  ==  7\n--    maximumR [\"todo\",\"es\",\"falso\"]      ==  \"todo\"\n--    maximumR [\"menos\",\"alguna\",\"cosa\"]  ==  \"menos\"\n-- \n-- Nota: La funci\u00f3n maximumR es equivalente a la predefinida maximum.\n-- ---------------------------------------------------------------------\n\nmaximumR :: Ord a => [a] -> a\nmaximumR [x]      = x\nmaximumR (x:y:ys) = max x (maximumR (y:ys))\nmaximumR _        = error \"Imposible\"\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 6.2. La funci\u00f3n de plegado foldr1 est\u00e1 definida por \n--    foldr1 :: (a -> a -> a) -> [a] -> a\n--    foldr1 _ [x]    =  x\n--    foldr1 f (x:xs) =  f x (foldr1 f xs)\n-- \n-- Definir, mediante plegado con foldr1, la funci\u00f3n\n--    maximumP :: Ord a => [a] -> a\n-- tal que (maximumR xs) es el m\u00e1ximo de la lista xs. Por ejemplo,\n--    maximumP [3,7,2,5]                  ==  7\n--    maximumP [\"todo\",\"es\",\"falso\"]      ==  \"todo\"\n--    maximumP [\"menos\",\"alguna\",\"cosa\"]  ==  \"menos\"\n-- \n-- Nota: La funci\u00f3n maximumP es equivalente a la predefinida maximum.\n-- ---------------------------------------------------------------------\n\nmaximumP :: Ord a => [a] -> a\nmaximumP = foldr1 max\n<\/pre>\n<p>Los soluciones de esta relaci\u00f3n, junto con las anteriores se encuentra recopidado en el <a href=\"https:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-18\/ejercicios\/ejercicios-I1M-2018.pdf\">libro de soluciones de ejercicios<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>En la segunda parte de la clase de hoy de Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas hemos comentado las soluciones de los primeros ejercicios de la relaci\u00f3n 7 sobre funciones de orden superior. Los ejercicios y su soluci\u00f3n 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":[320],"tags":[270,321],"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\/6378"}],"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=6378"}],"version-history":[{"count":1,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/6378\/revisions"}],"predecessor-version":[{"id":6379,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/6378\/revisions\/6379"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=6378"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=6378"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=6378"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}