{"id":3835,"date":"2013-11-19T17:22:55","date_gmt":"2013-11-19T16:22:55","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=3835"},"modified":"2013-11-21T07:23:48","modified_gmt":"2013-11-21T06:23:48","slug":"i1m2013-definiciones-por-recursion-2","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2013-definiciones-por-recursion-2\/","title":{"rendered":"I1M2013: Definiciones por recursi\u00f3n (2)"},"content":{"rendered":"<p>En la clase de hoy de <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-13\">Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas<\/a> hemos continuado el estudio de las definiciones por recursi\u00f3n en Haskell. Concretamente, hemos visto ejemplos de recursi\u00f3n sobre varios argumento, recursi\u00f3n m\u00faltiple y de recursi\u00f3n mutua. Tambi\u00e9n hemos comentado el m\u00e9todo para construir funciones recursivas.<\/p>\n<p>\nLas transparencias usadas en la clase son las las p\u00e1ginas 10 a 24 del <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-12\/temas\/tema-6t.pdf\">tema 6<\/a>:<br \/>\n<!--more--><br \/>\n<div class=\"jetpack-video-wrapper\"><iframe src='https:\/\/www.slideshare.net\/slideshow\/embed_code\/5667945' width='1290' height='1057' sandbox=\"allow-popups allow-scripts allow-same-origin allow-presentation\" allowfullscreen webkitallowfullscreen mozallowfullscreen><\/iframe><\/div><\/p>\n<p>El c\u00f3digo correspondiente es<\/p>\n<pre lang=\"haskell\">\r\n-- ---------------------------------------------------------------------\r\n-- Recursi\u00f3n sobre varios argumentos                                  --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- (zip xs ys) es la lista de los pares de los elementos de xs e ys en\r\n-- la misma posici\u00f3n. Por ejemplo,\r\n--    zip [1,3,5] [2,4,6,8]  ==  [(1,2),(3,4),(5,6)]\r\nzip :: [a] -> [b] -> [(a, b)]\r\nzip []     _      = []\r\nzip _      []     = []\r\nzip (x:xs) (y:ys) = (x,y) : zip xs ys\r\n\r\n-- (drop n xs) es la lista obtenida eliminando los n primeros elementos\r\n-- de xs. Por ejemplo,\r\n--    drop 2 [5,7,9,4] == [9,4]\r\n--    drop 5 [1,4]     ==  [] \r\ndrop :: Int -> [a] -> [a]\r\ndrop 0 xs         = xs\r\ndrop (n+1) []     = []\r\ndrop (n+1) (x:xs) = drop n xs\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Recursi\u00f3n m\u00faltiple                                                 --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- (fibonacci n) es el n--\u00e9simo t\u00e9rmino de la sucesi\u00f3n de Fibonacci. Por\r\n-- ejemplo, \r\n--    fibonacci 8  ==  21  \r\nfibonacci :: Int -> Int\r\nfibonacci 0     = 0\r\nfibonacci 1     = 1\r\nfibonacci (n+2) = fibonacci n + fibonacci (n+1)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Recursi\u00f3n m\u00faltiple                                                 --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- (ordena xs) es la lista obtenida ordenando xs meciante el algoritmo\r\n-- de ordenaci\u00f3n r\u00e1pida. Por ejemplo,\r\n--    ordena [2,5,4,7]  ==  [2,4,5,7]\r\nordena :: (Ord a) => [a] -> [a]\r\nordena [] = []\r\nordena (x:xs) = \r\n    (ordena menores) ++ [x] ++ (ordena mayores)\r\n    where menores = [a | a <- xs, a <= x]\r\n          mayores = [b | b <- xs, b > x]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Recursi\u00f3n mutua                                                    --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- (par x) se verifica si x es par e (impar x) se verifica si x es\r\n-- impar. Por ejemplo,\r\n--    par 3    ==  False\r\n--    impar 3  ==  True\r\npar :: Int -> Bool\r\npar 0     = True\r\npar (n+1) = impar n\r\n\r\nimpar :: Int -> Bool\r\nimpar 0      = False\r\nimpar (n+1)  = par n\r\n\r\n-- (pares xs) son los elementos de xs que ocupan posiciones pares e\r\n-- (impares xs) son los elementos de xs que ocupan posiciones\r\n-- impares. Por ejemplo,\r\n--    pares [1,3,5,7]  ==  [1,5]  \r\npares :: [a] -> [a]\r\npares []     = []\r\npares (x:xs) = x : impares xs\r\n\r\nimpares :: [a] -> [a]\r\nimpares []     = []\r\nimpares (_:xs) = pares xs\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Heur\u00edsticas para las definiciones recursivas                       --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- (init xs) es la lista xs sin el \u00faltimo elemento. Por ejemplo,\r\n--    init [3,2,5]  ==  [2,5] \r\ninit :: [a] -> [a]\r\ninit [_]    = []\r\ninit (x:xs) = x : init xs\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 continuado el estudio de las definiciones por recursi\u00f3n en Haskell. Concretamente, hemos visto ejemplos de recursi\u00f3n sobre varios argumento, recursi\u00f3n m\u00faltiple y de recursi\u00f3n mutua. Tambi\u00e9n hemos comentado el m\u00e9todo para construir funciones recursivas. Las transparencias usadas en la clase son&#8230;<\/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],"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\/3835"}],"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=3835"}],"version-history":[{"count":1,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/3835\/revisions"}],"predecessor-version":[{"id":3836,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/3835\/revisions\/3836"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=3835"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=3835"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=3835"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}