{"id":3981,"date":"2013-12-20T17:32:23","date_gmt":"2013-12-20T16:32:23","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=3981"},"modified":"2014-01-07T07:33:57","modified_gmt":"2014-01-07T06:33:57","slug":"i1m2013-ejercicios-sobre-funciones-de-orden-superior-y-plegados-2","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2013-ejercicios-sobre-funciones-de-orden-superior-y-plegados-2\/","title":{"rendered":"I1M2013: Ejercicios sobre funciones de orden superior y plegados (2)"},"content":{"rendered":"<p>En 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 6 a 11 de la 12\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 Test.QuickCheck\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 6. Definir la funci\u00f3n\r\n--    relacionados :: (a -> a -> Bool) -> [a] -> Bool\r\n-- tal que (relacionados r xs) se verifica si para todo par (x,y) de\r\n-- elementos consecutivos de xs se cumple la relaci\u00f3n r. Por ejemplo,\r\n--    relacionados (<) [2,3,7,9]                ==  True\r\n--    relacionados (<) [2,3,1,9]                ==  False\r\n-- ---------------------------------------------------------------------\r\n\r\nrelacionados :: (a -> a -> Bool) -> [a] -> Bool\r\nrelacionados r (x:y:zs) = (r x y) && relacionados r (y:zs)\r\nrelacionados _ _ = True\r\n\r\n-- Una definici\u00f3n alternativa es\r\nrelacionados' :: (a -> a -> Bool) -> [a] -> Bool\r\nrelacionados' r xs = and [r x y | (x,y) <- zip xs (tail xs)]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 7. Definir la funci\u00f3n\r\n--    agrupa :: Eq a => [[a]] -> [[a]]\r\n-- tal que (agrupa xss) es la lista de las listas obtenidas agrupando\r\n-- los primeros elementos, los segundos, ... Por ejemplo, \r\n--    agrupa [[1..6],[7..9],[10..20]]  ==  [[1,7,10],[2,8,11],[3,9,12]]\r\n--    agrupa []                        ==  []\r\n-- ---------------------------------------------------------------------\r\n\r\nagrupa :: Eq a => [[a]] -> [[a]]\r\nagrupa []  = []\r\nagrupa xss\r\n    | [] `elem` xss = []\r\n    | otherwise     = primeros xss : agrupa (restos xss)\r\n    where primeros = map head\r\n          restos   = map tail\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 8.1. Definir por recursi\u00f3n la funci\u00f3n\r\n--    superpar :: Int -> Bool\r\n-- tal que (superpar n) se verifica si n es un n\u00famero par tal que todos\r\n-- sus d\u00edgitos son pares. Por ejemplo,\r\n--    superpar 426  ==  True\r\n--    superpar 456  ==  False\r\n-- ---------------------------------------------------------------------\r\n\r\nsuperpar :: Int -> Bool\r\nsuperpar n | n < 10    = even n\r\n           | otherwise = even n &#038;&#038; superpar (n `div` 10)\r\n\r\n-- Otra forma equivalente es\r\nsuperpar' :: Int -> Bool\r\nsuperpar' 0 = True\r\nsuperpar' n = even n && superpar' (div n 10)  \r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 8.2. Definir por comprensi\u00f3n la funci\u00f3n\r\n--    superpar2 :: Int -> Bool\r\n-- tal que (superpar2 n) se verifica si n es un n\u00famero par tal que todos\r\n-- sus d\u00edgitos son pares. Por ejemplo,\r\n--    superpar2 426  ==  True\r\n--    superpar2 456  ==  False\r\n-- ---------------------------------------------------------------------\r\n\r\nsuperpar2 :: Int -> Bool\r\nsuperpar2 n = and [even d | d <- digitos n]\r\n\r\ndigitos :: Int -> [Int]\r\ndigitos n = [read [d] | d <- show n]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 8.3. Definir, por recursi\u00f3n sobre los d\u00edgitos, la funci\u00f3n\r\n--    superpar3 :: Int -> Bool\r\n-- tal que (superpar3 n) se verifica si n es un n\u00famero par tal que todos\r\n-- sus d\u00edgitos son pares. Por ejemplo,\r\n--    superpar3 426  ==  True\r\n--    superpar3 456  ==  False\r\n-- ---------------------------------------------------------------------\r\n\r\nsuperpar3 :: Int -> Bool\r\nsuperpar3 n = sonPares (digitos n)\r\n    where sonPares []     = True\r\n          sonPares (d:ds) = even d && sonPares ds\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 8.3. Definir, usando all, la funci\u00f3n\r\n--    superpar4 :: Int -> Bool\r\n-- tal que (superpar4 n) se verifica si n es un n\u00famero par tal que todos\r\n-- sus d\u00edgitos son pares. Por ejemplo,\r\n--    superpar4 426  ==  True\r\n--    superpar4 456  ==  False\r\n-- ---------------------------------------------------------------------\r\n\r\nsuperpar4 :: Int -> Bool\r\nsuperpar4 n = all even (digitos n)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 8.5. Definir, usando filter, la funci\u00f3n\r\n--    superpar5 :: Int -> Bool\r\n-- tal que (superpar5 n) se verifica si n es un n\u00famero par tal que todos\r\n-- sus d\u00edgitos son pares. Por ejemplo,\r\n--    superpar5 426  ==  True\r\n--    superpar5 456  ==  False\r\n-- ---------------------------------------------------------------------\r\n\r\nsuperpar5 :: Int -> Bool\r\nsuperpar5 n = filter even (digitos n) == digitos n\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 9. Se considera la funci\u00f3n \r\n--    filtraAplica :: (a -> b) -> (a -> Bool) -> [a] -> [b]\r\n-- tal que (filtraAplica f p xs) es la lista obtenida aplic\u00e1ndole a los\r\n-- elementos de xs que cumplen el predicado p la funci\u00f3n f. Por ejemplo,\r\n--    filtraAplica (4+) (<3) [1..7]  =>  [5,6]\r\n-- Se pide, definir la funci\u00f3n\r\n-- 1. por comprensi\u00f3n,\r\n-- 2. usando map y filter,\r\n-- 3. por recursi\u00f3n y\r\n-- 4. por plegado (con foldr).\r\n-- ---------------------------------------------------------------------\r\n\r\n-- La definici\u00f3n con lista de comprensi\u00f3n es\r\nfiltraAplica_1 :: (a -> b) -> (a -> Bool) -> [a] -> [b]\r\nfiltraAplica_1 f p xs = [f x | x <- xs, p x]\r\n\r\n-- La definici\u00f3n con map y filter es\r\nfiltraAplica_2 :: (a -> b) -> (a -> Bool) -> [a] -> [b]\r\nfiltraAplica_2 f p xs = map f (filter p xs)\r\n\r\n-- La definici\u00f3n por recursi\u00f3n es\r\nfiltraAplica_3 :: (a -> b) -> (a -> Bool) -> [a] -> [b]\r\nfiltraAplica_3 f p [] = []\r\nfiltraAplica_3 f p (x:xs) | p x       = f x : filtraAplica_3 f p xs\r\n                          | otherwise = filtraAplica_3 f p xs\r\n\r\n-- La definici\u00f3n por plegado es\r\nfiltraAplica_4 :: (a -> b) -> (a -> Bool) -> [a] -> [b]\r\nfiltraAplica_4 f p = foldr g []\r\n                     where g x y | p x       = f x : y\r\n                                 | otherwise = y\r\n\r\n-- La definici\u00f3n por plegado usando lambda es\r\nfiltraAplica_4' :: (a -> b) -> (a -> Bool) -> [a] -> [b]\r\nfiltraAplica_4' f p = \r\n    foldr (\\x y -> if p x then (f x : y) else y) []\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 10.1. Definir, mediante recursi\u00f3n, la funci\u00f3n\r\n--    maximumR :: Ord a => [a] -> a\r\n-- tal que (maximumR xs) es el m\u00e1ximo de la lista xs. Por ejemplo,\r\n--    maximumR [3,7,2,5]                  ==  7\r\n--    maximumR [\"todo\",\"es\",\"falso\"]      ==  \"todo\"\r\n--    maximumR [\"menos\",\"alguna\",\"cosa\"]  ==  \"menos\"\r\n-- Nota: La funci\u00f3n maximumR es equivalente a la predefinida maximum.\r\n-- ---------------------------------------------------------------------\r\n\r\nmaximumR :: Ord a => [a] -> a\r\nmaximumR [x]      = x\r\nmaximumR (x:y:ys) = max x (maximumR (y:ys))\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 10.2. La funci\u00f3n de plegado foldr1 est\u00e1 definida por \r\n--    foldr1 :: (a -> a -> a) -> [a] -> a\r\n--    foldr1 _ [x]    =  x\r\n--    foldr1 f (x:xs) =  f x (foldr1 f xs)\r\n-- \r\n-- Definir, mediante plegado con foldr1, la funci\u00f3n\r\n--    maximumP :: Ord a => [a] -> a\r\n-- tal que (maximumR xs) es el m\u00e1ximo de la lista xs. Por ejemplo,\r\n--    maximumP [3,7,2,5]                  ==  7\r\n--    maximumP [\"todo\",\"es\",\"falso\"]      ==  \"todo\"\r\n--    maximumP [\"menos\",\"alguna\",\"cosa\"]  ==  \"menos\"\r\n-- Nota: La funci\u00f3n maximumP es equivalente a la predefinida maximum.\r\n-- ---------------------------------------------------------------------\r\n\r\nmaximumP :: Ord a => [a] -> a\r\nmaximumP = foldr1 max\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 11. Definir, mediante plegado con foldr1, la funci\u00f3n\r\n--    minimunP :: Ord a => [a] -> a\r\n-- tal que (minimunR xs) es el m\u00e1ximo de la lista xs. Por ejemplo,\r\n--    minimunP [3,7,2,5]                  ==  2\r\n--    minimumP [\"todo\",\"es\",\"falso\"]      ==  \"es\"\r\n--    minimumP [\"menos\",\"alguna\",\"cosa\"]  ==  \"alguna\"\r\n-- Nota: La funci\u00f3n minimunP es equivalente a la predefinida minimun.\r\n-- ---------------------------------------------------------------------\r\n\r\nminimumP :: Ord a => [a] -> a\r\nminimumP = foldr1 min\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"<p>En la clase de hoy del curso Inform\u00e1tica (de 1\u00ba de Grado en Matem\u00e1ticas) se han comentado las soluciones de los ejercicios 6 a 11 de la 12\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,1],"tags":[270,300],"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\/3981"}],"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=3981"}],"version-history":[{"count":1,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/3981\/revisions"}],"predecessor-version":[{"id":3982,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/3981\/revisions\/3982"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=3981"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=3981"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=3981"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}