{"id":4132,"date":"2014-02-14T20:01:28","date_gmt":"2014-02-14T19:01:28","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=4132"},"modified":"2014-02-18T06:21:19","modified_gmt":"2014-02-18T05:21:19","slug":"i1m2013-ejercicios-de-evaluacion-perezosa-y-listas-infinitas-en-haskell-3","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2013-ejercicios-de-evaluacion-perezosa-y-listas-infinitas-en-haskell-3\/","title":{"rendered":"I1M2013: Ejercicios de evaluaci\u00f3n perezosa y listas infinitas en Haskell (3)"},"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 comentado las soluciones de los dos primeros ejercicios sobre evaluaci\u00f3n perezosa y listas infinitas de la <a href=\"http:\/\/bit.ly\/1c9osTa\">relaci\u00f3n 17<\/a>.<\/p>\n<p>Los ejercicios de la relaci\u00f3n 17, y sus soluciones, se muestran a continuaci\u00f3n.<br \/>\n<!--more--><\/p>\n<pre lang=\"haskell\">\r\n-- ---------------------------------------------------------------------\r\n-- \u00a7 Librer\u00edas auxiliares                                             --\r\n-- ---------------------------------------------------------------------\r\n\r\nimport Data.Char \r\nimport Data.List \r\nimport Test.QuickCheck\r\n\r\n-- ---------------------------------------------------------------------\r\n-- \u00a7 La lista infinita de factoriales,                                --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.1. Definir, por comprensi\u00f3n, la funci\u00f3n\r\n--    factoriales1 :: [Integer]\r\n-- tal que factoriales1 es la lista de los factoriales. Por ejemplo,\r\n--    take 10 factoriales1  ==  [1,1,2,6,24,120,720,5040,40320,362880]\r\n-- ---------------------------------------------------------------------\r\n\r\nfactoriales1 :: [Integer]\r\nfactoriales1 = [factorial n | n <- [0..]]\r\n\r\n-- (factorial n) es el factorial de n. Por ejemplo,\r\n--    factorial 4  ==  24\r\nfactorial :: Integer -> Integer\r\nfactorial n = product [1..n]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.2. Definir, usando zipWith, la funci\u00f3n\r\n--    factoriales2 :: [Integer]\r\n-- tal que factoriales2 es la lista de los factoriales. Por ejemplo,\r\n--    take 10 factoriales2  ==  [1,1,2,6,24,120,720,5040,40320,362880]\r\n-- ---------------------------------------------------------------------\r\n\r\nfactoriales2 :: [Integer]\r\nfactoriales2 = 1 : zipWith (*) [1..] factoriales2\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.3. Comparar el tiempo y espacio necesarios para calcular\r\n-- las siguientes expresiones\r\n--    let xs = take 3000 factoriales1 in (sum xs - sum xs)\r\n--    let xs = take 3000 factoriales2 in (sum xs - sum xs)\r\n-- ---------------------------------------------------------------------\r\n\r\n-- El c\u00e1lculo es\r\n--    ghci> let xs = take 3000 factoriales1 in (sum xs - sum xs)\r\n--    0\r\n--    (17.51 secs, 5631214332 bytes)\r\n--    ghci> let xs = take 3000 factoriales2 in (sum xs - sum xs)\r\n--    0\r\n--    (0.04 secs, 17382284 bytes)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.4. Definir, por recursi\u00f3n, la funci\u00f3n\r\n--    factoriales3 :: [Integer]\r\n-- tal que factoriales3 es la lista de los factoriales. Por ejemplo,\r\n--    take 10 factoriales3  ==  [1,1,2,6,24,120,720,5040,40320,362880]\r\n-- ---------------------------------------------------------------------\r\n\r\nfactoriales3 :: [Integer]\r\nfactoriales3 = 1 : aux 1 [1..]\r\n    where aux x (y:ys) = z : aux z ys where z = x*y\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.5. Comparar el tiempo y espacio necesarios para calcular\r\n-- las siguientes expresiones\r\n--    let xs = take 3000 factoriales2 in (sum xs - sum xs)\r\n--    let xs = take 3000 factoriales3 in (sum xs - sum xs)\r\n-- ---------------------------------------------------------------------\r\n\r\n-- El c\u00e1lculo es\r\n--    ghci> let xs = take 3000 factoriales2 in (sum xs - sum xs)\r\n--    0\r\n--    (0.04 secs, 17382284 bytes)\r\n--    ghci> let xs = take 3000 factoriales3 in (sum xs - sum xs)\r\n--    0\r\n--    (0.04 secs, 18110224 bytes)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.6. Definir, usando scanl1, la funci\u00f3n\r\n--    factoriales4 :: [Integer]\r\n-- tal que factoriales4 es la lista de los factoriales. Por ejemplo,\r\n--    take 10 factoriales4  ==  [1,1,2,6,24,120,720,5040,40320,362880]\r\n-- ---------------------------------------------------------------------\r\n\r\nfactoriales4 :: [Integer]\r\nfactoriales4 = 1 : scanl1 (*) [1..]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.7. Comparar el tiempo y espacio necesarios para calcular\r\n-- las siguientes expresiones\r\n--    let xs = take 3000 factoriales3 in (sum xs - sum xs)\r\n--    let xs = take 3000 factoriales4 in (sum xs - sum xs)\r\n-- ---------------------------------------------------------------------\r\n\r\n-- El c\u00e1lculo es\r\n--    ghci> let xs = take 3000 factoriales3 in (sum xs - sum xs)\r\n--    0\r\n--    (0.04 secs, 18110224 bytes)\r\n--    ghci> let xs = take 3000 factoriales4 in (sum xs - sum xs)\r\n--    0\r\n--    (0.03 secs, 11965328 bytes)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.8. Definir, usando iterate, la funci\u00f3n\r\n--    factoriales5 :: [Integer]\r\n-- tal que factoriales5 es la lista de los factoriales. Por ejemplo,\r\n--    take 10 factoriales5  ==  [1,1,2,6,24,120,720,5040,40320,362880]\r\n-- ---------------------------------------------------------------------\r\n\r\nfactoriales5 :: [Integer]\r\nfactoriales5 = map snd aux\r\n    where aux = iterate f (1,1) where f (x,y) = (x+1,x*y)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.9. Comparar el tiempo y espacio necesarios para calcular\r\n-- las siguientes expresiones\r\n--    let xs = take 3000 factoriales4 in (sum xs - sum xs)\r\n--    let xs = take 3000 factoriales5 in (sum xs - sum xs)\r\n-- ---------------------------------------------------------------------\r\n\r\n-- El c\u00e1lculo es\r\n--    ghci> let xs = take 3000 factoriales4 in (sum xs - sum xs)\r\n--    0\r\n--    (0.04 secs, 18110224 bytes)\r\n--    ghci> let xs = take 3000 factoriales5 in (sum xs - sum xs)\r\n--    0\r\n--    (0.03 secs, 11965760 bytes)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- \u00a7 La sucesi\u00f3n de Fibonacci                                         --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2.1. La sucesi\u00f3n de Fibonacci est\u00e1 definida por\r\n--    f(0) = 0\r\n--    f(1) = 1\r\n--    f(n) = f(n-1)+f(n-2), si n > 1.\r\n-- \r\n-- Definir la funci\u00f3n\r\n--    fib :: Integer -> Integer\r\n-- tal que (fib n) es el n-\u00e9simo t\u00e9rmino de la sucesi\u00f3n de Fibonacci. \r\n-- Por ejemplo,\r\n--    fib 8  ==  21\r\n-- ---------------------------------------------------------------------\r\n\r\nfib :: Integer -> Integer\r\nfib 0 = 0\r\nfib 1 = 1\r\nfib n = fib (n-1) + fib (n-2)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2.2. Definir, por comprensi\u00f3n, la funci\u00f3n\r\n--    fibs1 :: [Integer]\r\n-- tal que fibs1 es la sucesi\u00f3n de Fibonacci. Por ejemplo,\r\n--    take 10 fibs1  ==  [0,1,1,2,3,5,8,13,21,34]\r\n-- ---------------------------------------------------------------------\r\n\r\nfibs1 :: [Integer]\r\nfibs1 = [fib n | n <- [0..]]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2.3. Definir, por recursi\u00f3n, la funci\u00f3n\r\n--    fibs2 :: [Integer]\r\n-- tal que fibs2 es la sucesi\u00f3n de Fibonacci. Por ejemplo,\r\n--    take 10 fibs2  ==  [0,1,1,2,3,5,8,13,21,34]\r\n-- ---------------------------------------------------------------------\r\n\r\nfibs2 :: [Integer]\r\nfibs2 = aux 0 1\r\n    where aux x y = x : aux y (x+y)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2.4. Comparar el tiempo y espacio necesarios para calcular\r\n-- las siguientes expresiones\r\n--    let xs = take 30 fibs1 in (sum xs - sum xs)\r\n--    let xs = take 30 fibs2 in (sum xs - sum xs)\r\n-- ---------------------------------------------------------------------\r\n\r\n-- El c\u00e1lculo es\r\n--    ghci> let xs = take 30 fibs1 in (sum xs - sum xs)\r\n--    0\r\n--    (6.02 secs, 421589672 bytes)\r\n--    ghci> let xs = take 30 fibs2 in (sum xs - sum xs)\r\n--    0\r\n--    (0.01 secs, 515856 bytes)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2.5. Definir, por recursi\u00f3n con zipWith, la funci\u00f3n\r\n--    fibs3 :: [Integer]\r\n-- tal que fibs3 es la sucesi\u00f3n de Fibonacci. Por ejemplo,\r\n--    take 10 fibs3  ==  [0,1,1,2,3,5,8,13,21,34]\r\n-- ---------------------------------------------------------------------\r\n\r\nfibs3 :: [Integer]\r\nfibs3 = 0 : 1: zipWith (+) fibs3 (tail fibs3)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2.6. Comparar el tiempo y espacio necesarios para calcular\r\n-- las siguientes expresiones\r\n--    let xs = take 40000 fibs2 in (sum xs - sum xs)\r\n--    let xs = take 40000 fibs3 in (sum xs - sum xs)\r\n-- ---------------------------------------------------------------------\r\n\r\n-- El c\u00e1lculo es\r\n--    ghci> let xs = take 40000 fibs2 in (sum xs - sum xs)\r\n--    0\r\n--    (0.90 secs, 221634544 bytes)\r\n--    ghci> let xs = take 40000 fibs3 in (sum xs - sum xs)\r\n--    0\r\n--    (1.14 secs, 219448176 bytes)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2.7. Definir, por recursi\u00f3n con acumuladores, la funci\u00f3n \r\n--    fibs4 :: [Integer]\r\n-- tal que fibs4 es la sucesi\u00f3n de Fibonacci. Por ejemplo,\r\n--    take 10 fibs4  ==  [0,1,1,2,3,5,8,13,21,34]\r\n-- ---------------------------------------------------------------------\r\n\r\nfibs4 :: [Integer]\r\nfibs4 = fs where (xs,ys,fs) = (zipWith (+) ys fs, 1:xs, 0:ys)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2.8. Comparar el tiempo y espacio necesarios para calcular\r\n-- las siguientes expresiones\r\n--    let xs = take 40000 fibs3 in (sum xs - sum xs)\r\n--    let xs = take 40000 fibs4 in (sum xs - sum xs)\r\n-- ---------------------------------------------------------------------\r\n\r\n-- El c\u00e1lculo es\r\n--    ghci> let xs = take 40000 fibs2 in (sum xs - sum xs)\r\n--    0\r\n--    (0.90 secs, 221634544 bytes)\r\n--    ghci> let xs = take 40000 fibs4 in (sum xs - sum xs)\r\n--    0\r\n--    (0.84 secs, 219587064 bytes)\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 comentado las soluciones de los dos primeros ejercicios sobre evaluaci\u00f3n perezosa y listas infinitas de la relaci\u00f3n 17. Los ejercicios de la relaci\u00f3n 17, y sus 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],"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\/4132"}],"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=4132"}],"version-history":[{"count":4,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/4132\/revisions"}],"predecessor-version":[{"id":4136,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/4132\/revisions\/4136"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=4132"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=4132"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=4132"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}