{"id":1672,"date":"2011-11-08T19:52:52","date_gmt":"2011-11-08T19:52:52","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2011-definiciones-por-recursion-en-haskell\/"},"modified":"2013-03-08T05:49:00","modified_gmt":"2013-03-08T05:49:00","slug":"i1m2011-definiciones-por-recursion-en-haskell","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2011-definiciones-por-recursion-en-haskell\/","title":{"rendered":"I1M2011:  Definiciones por recursi\u00f3n en Haskell"},"content":{"rendered":"<p>En la clase de hoy de <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-11\">Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas<\/a> hemos iniciado el estudio de las definiciones por recursi\u00f3n en Haskell. Concretamente, hemos visto ejemplos de recursi\u00f3n sobre los n\u00fameros naturales, recursi\u00f3n sobre listas, recursi\u00f3n sobre listas que necesitan guardas en el caso recursivo y recursi\u00f3n sobre varios argumentos.<\/p>\n<p>\nComo tarea para la pr\u00f3xima clase se ha propuesto escribir de manera colaborativa las soluciones de los ejercicios de la <a href=\"https:\/\/www.glc.us.es\/~jalonso\/ejerciciosI1M2011G1\/images\/b\/b1\/Rel_6.hs\">6\u00aa relaci\u00f3n<\/a>.<\/p>\n<p>\nLas transparencias usadas en la clase son las comprendidas entre las p\u00e1ginas 1 y 11 del <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-11\/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-- Librer\u00edas auxiliares                                               --\r\n-- ---------------------------------------------------------------------\r\n\r\nimport Prelude hiding (product, reverse, length, (++), zip, drop, init)\r\nimport Data.Char  \r\n\r\n-- ---------------------------------------------------------------------\r\n-- Recursi\u00f3n num\u00e9rica                                                 --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- (factorial n) es el factorial de n. Por ejemplo,\r\n--    factorial 3  ==  6\r\nfactorial :: Integer -> Integer\r\nfactorial 0     = 1\r\nfactorial (n+1) = (n+1) * factorial n\r\n\r\n-- (m `por` n) es el producto de m por n. Por ejemplo,\r\n--    3 `por` 2  ==  6\r\npor :: Int -> Int -> Int\r\nm `por` 0       = 0\r\nm `por` (n + 1) = m + (m `por` n)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Recusi\u00f3n sobre lista                                               --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- (product xs) es el producto de los n\u00fameros de xs. Por ejemplo,\r\n--    product [7,5,2] == 70\r\nproduct :: Num a => [a] -> a\r\nproduct []     = 1\r\nproduct (n:ns) = n * product ns\r\n\r\n-- (length xs) es el n\u00famero de elementos de xs. Por ejemplo,\r\n--    length [2,4,5] == 3\r\nlength :: [a] -> Int\r\nlength []     = 0\r\nlength (_:xs) = 1 + length xs\r\n\r\n-- (reverse xs) es la inversa de xs. Por ejemplo,\r\n--    reverse [2,5,3]  ==  [3,5,2]  \r\nreverse :: [a] -> [a]\r\nreverse []     = []\r\nreverse (x:xs) = reverse xs ++ [x]\r\n\r\n-- (xs ++ ys) es la concatenaci\u00f3n de xs e ys. Por ejemplo,\r\n--    [2,5] ++ [3,5,6]  ==  [2,5,3,5,6]\r\n(++) :: [a] -> [a] -> [a]\r\n[]     ++ ys = ys\r\n(x:xs) ++ ys = x : (xs ++ ys)\r\n\r\n-- (inserta e xs) inserta el elemento e en la lista xs delante del\r\n-- primer elemento de xs mayor o igual que e. Por ejemplo,\r\n--    inserta 5 [2,4,7,3,6,8,10] == [2,4,5,7,3,6,8,10]  \r\ninserta :: Ord a => a -> [a] -> [a]\r\ninserta e []                  = [e]\r\ninserta e (x:xs) | e <= x     = e : (x:xs) \r\n                 | otherwise  = x : inserta e xs    \r\n\r\n-- (ordena_por_insercion xs) es la lista xs ordenada mediante inserci\u00f3n,\r\n-- Por ejemplo, \r\n--    ordena_por_insercion [2,4,3,6,3] == [2,3,3,4,6]  \r\nordena_por_insercion :: Ord a => [a] -> [a]\r\nordena_por_insercion []     = []\r\nordena_por_insercion (x:xs) = \r\n    inserta x (ordena_por_insercion xs)   \r\n\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<\/pre>\n","protected":false},"excerpt":{"rendered":"<p>En la clase de hoy de Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas hemos iniciado el estudio de las definiciones por recursi\u00f3n en Haskell. Concretamente, hemos visto ejemplos de recursi\u00f3n sobre los n\u00fameros naturales, recursi\u00f3n sobre listas, recursi\u00f3n sobre listas que necesitan guardas en el caso recursivo y recursi\u00f3n sobre varios argumentos. Como tarea para&#8230;<\/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":[186],"tags":[295],"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\/1672"}],"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=1672"}],"version-history":[{"count":2,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/1672\/revisions"}],"predecessor-version":[{"id":2919,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/1672\/revisions\/2919"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=1672"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=1672"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=1672"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}