{"id":2392,"date":"2012-12-10T12:29:01","date_gmt":"2012-12-10T12:29:01","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=2392"},"modified":"2013-03-08T05:47:37","modified_gmt":"2013-03-08T05:47:37","slug":"i1m2012-ejercicios-de-definiciones-por-recursion-y-comprension-en-haskell-4","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2012-ejercicios-de-definiciones-por-recursion-y-comprension-en-haskell-4\/","title":{"rendered":"I1M2012: Ejercicios de definiciones por recursi\u00f3n y comprensi\u00f3n en Haskell (4)"},"content":{"rendered":"<p>En la clase de hoy de <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-12\">Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas<\/a> hemos comentado las soluciones de los ejercicios 4 y 5 de la <a href=\"https:\/\/www.glc.us.es\/~jalonso\/ejerciciosI1M2012G2\/images\/6\/6c\/Rel_10.hs\">10\u00aa relaci\u00f3n<\/a> y 1 a 5 de la <a href=\"https:\/\/www.glc.us.es\/~jalonso\/ejerciciosI1M2012G2\/images\/6\/6c\/Rel_11.hs\">11\u00aa relaci\u00f3n<\/a> en las que se presentan ejercicios con dos definiciones (una por recursi\u00f3n y otra por comprensi\u00f3n) y la comprobaci\u00f3n de la equivalencia de las dos definiciones con QuickCheck. <\/p>\n<p>Los ejercicios, y sus soluciones, se muestran a continuaci\u00f3n: Los de la relaci\u00f3n 10 son<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-- ---------------------------------------------------------------------\r\n-- Ejercicio 4.1. Definir, por comprensi\u00f3n, la funci\u00f3n\r\n--    sumaCuadradosImparesC :: [Integer] -> Integer\r\n-- tal que (sumaCuadradosImparesC xs) es la suma de los cuadrados de los\r\n-- n\u00fameros impares de la lista xs. Por ejemplo,\r\n--    sumaCuadradosImparesC [1,2,3]  ==  10\r\n-- ---------------------------------------------------------------------\r\n\r\nsumaCuadradosImparesC :: [Integer] -> Integer\r\nsumaCuadradosImparesC xs = sum [x^2 | x <- xs, odd x]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 4.2. Definir, por recursi\u00f3n, la funci\u00f3n\r\n--    sumaCuadradosImparesR :: [Integer] -> Integer\r\n-- tal que (sumaCuadradosImparesR xs) es la suma de los cuadrados de los\r\n-- n\u00fameros impares de la lista xs. Por ejemplo,\r\n--    sumaCuadradosImparesR [1,2,3]  ==  10\r\n-- ---------------------------------------------------------------------\r\n\r\nsumaCuadradosImparesR :: [Integer] -> Integer\r\nsumaCuadradosImparesR []                  = 0\r\nsumaCuadradosImparesR (x:xs) \r\n    | odd x     = x^2 + sumaCuadradosImparesR xs\r\n    | otherwise = sumaCuadradosImparesR xs\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 5.1. Definir, usando funciones predefinidas, la funci\u00f3n\r\n--    entreL :: Integer -> Integer -> [Integer]\r\n-- tal que (entreL m n) es la lista de los n\u00fameros entre m y n. Por\r\n-- ejemplo, \r\n--    entreL 2 5  ==  [2,3,4,5]\r\n-- ---------------------------------------------------------------------\r\n\r\nentreL :: Integer -> Integer -> [Integer]\r\nentreL m n = [m..n]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 5.2. Definir, por recursi\u00f3n, la funci\u00f3n\r\n--    entreR :: Integer -> Integer -> [Integer]\r\n-- tal que (entreR m n) es la lista de los n\u00fameros entre m y n. Por\r\n-- ejemplo, \r\n--    entreR 2 5  ==  [2,3,4,5]\r\n-- ---------------------------------------------------------------------\r\n\r\nentreR :: Integer -> Integer -> [Integer]\r\nentreR m n | m > n     = []\r\n           | otherwise = m : entreR (m+1) n\r\n<\/pre>\n<p>y los de la relaci\u00f3n 11 son<\/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-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.1. Definir, por comprensi\u00f3n, la funci\u00f3n\r\n--    mitadPares :: [Int] -> [Int]\r\n-- tal que (mitadPares xs) es la lista de las mitades de los elementos\r\n-- de xs que son pares. Por ejemplo,\r\n--    mitadPares [0,2,1,7,8,56,17,18]  ==  [0,1,4,28,9]\r\n-- ---------------------------------------------------------------------\r\n\r\nmitadPares :: [Int] -> [Int]\r\nmitadPares xs = [x `div` 2 | x <- xs, even x]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.2. Definir, por recursi\u00f3n, la funci\u00f3n\r\n--    mitadParesRec :: [Int] -> [Int]\r\n-- tal que (mitadParesRec []) es la lista de las mitades de los elementos\r\n-- de xs que son pares. Por ejemplo,\r\n--    mitadParesRec [0,2,1,7,8,56,17,18]  ==  [0,1,4,28,9]\r\n-- ---------------------------------------------------------------------\r\n\r\nmitadParesRec :: [Int] -> [Int]\r\nmitadParesRec [] = []\r\nmitadParesRec (x:xs)\r\n    | even x    = x `div` 2 : mitadParesRec xs\r\n    | otherwise = mitadParesRec xs\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.3. Comprobar con QuickCheck que ambas definiciones son\r\n-- equivalentes. \r\n-- ---------------------------------------------------------------------\r\n\r\n-- La propiedad es\r\nprop_mitadPares :: [Int] -> Bool\r\nprop_mitadPares xs = \r\n    mitadPares xs == mitadParesRec xs\r\n\r\n-- La comprobaci\u00f3n es\r\n--    ghci> quickCheck prop_mitadPares\r\n--    +++ OK, passed 100 tests.\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2.1. Definir, por comprensi\u00f3n, la funci\u00f3n\r\n--    enRangoC :: Int -> Int -> [Int] -> [Int]\r\n-- tal que (enRangoC a b xs) es la lista de los elementos de xs mayores o\r\n-- iguales que a y menores o iguales que b. Por ejemplo,\r\n--    enRangoC  5 10 [1..15]   ==  [5,6,7,8,9,10]\r\n--    enRangoC  5 10 [7,2,9,3] ==  [7,9]\r\n--    enRangoC 10  5 [1..15]   ==  []\r\n--    enRangoC  5  5 [1..15]   ==  [5]\r\n-- ---------------------------------------------------------------------\r\n\r\nenRangoC :: Int -> Int -> [Int] -> [Int]\r\nenRangoC a b xs = [x | x <- xs, a <= x, x <= b]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2.2. Definir, por recursi\u00f3n, la funci\u00f3n\r\n--    enRangoR :: Int -> Int -> [Int] -> [Int]\r\n-- tal que (enRangoR a b []) es la lista de los elementos de xs\r\n-- mayores o iguales que a y menores o iguales que b. Por ejemplo,\r\n--    enRangoR  5 10 [1..15]   ==  [5,6,7,8,9,10]\r\n--    enRangoR  5 10 [7,2,9,3] == [7,9]\r\n--    enRangoR 10 5 [1..15]    ==  []\r\n--    enRangoR  5 5 [1..15]    ==  [5]\r\n-- ---------------------------------------------------------------------\r\n\r\nenRangoR :: Int -> Int -> [Int] -> [Int]\r\nenRangoR a b [] = []\r\nenRangoR a b (x:xs)\r\n    | a <= x &#038;&#038; x <= b  = x : enRangoR a b xs\r\n    | otherwise         = enRangoR a b xs\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2.3. Comprobar con QuickCheck que ambas definiciones son\r\n-- equivalentes. \r\n-- ---------------------------------------------------------------------\r\n\r\n-- La propiedad es\r\nprop_enRangoC :: Int -> Int -> [Int] -> Bool\r\nprop_enRangoC a b xs = \r\n    enRangoC a b xs == enRangoR a b xs\r\n\r\n-- La comprobaci\u00f3n es\r\n--    ghci> quickCheck prop_enRango\r\n--    +++ OK, passed 100 tests.\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 3.1. Definir, por comprensi\u00f3n, la funci\u00f3n\r\n--    sumaPositivosC :: [Int] -> Int\r\n-- tal que (sumaPositivosC xs) es la suma de los n\u00fameros positivos de\r\n-- xs. Por ejemplo, \r\n--    sumaPositivosC [0,1,-3,-2,8,-1,6]  ==  15\r\n-- ---------------------------------------------------------------------\r\n\r\nsumaPositivosC :: [Int] -> Int\r\nsumaPositivosC xs = sum [x | x <- xs, x > 0]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 3.2. Definir, por recursi\u00f3n, la funci\u00f3n\r\n--    sumaPositivosR :: [Int] -> Int\r\n-- tal que (sumaPositivosR xs) es la suma de los n\u00fameros positivos de\r\n-- xs. Por ejemplo, \r\n--    sumaPositivosR [0,1,-3,-2,8,-1,6]  ==  15\r\n-- ---------------------------------------------------------------------\r\n\r\nsumaPositivosR :: [Int] -> Int\r\nsumaPositivosR [] = 0\r\nsumaPositivosR (x:xs) | x > 0     = x + sumaPositivosR xs\r\n                      | otherwise = sumaPositivosR xs\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 3.3. Comprobar con QuickCheck que ambas definiciones son\r\n-- equivalentes. \r\n-- ---------------------------------------------------------------------\r\n\r\n-- La propiedad es\r\nprop_sumaPositivosC :: [Int] -> Bool\r\nprop_sumaPositivosC xs = \r\n    sumaPositivosC xs == sumaPositivosR xs\r\n\r\n-- La comprobaci\u00f3n es\r\n--    ghci> quickCheck prop_sumaPositivos\r\n--    +++ OK, passed 100 tests.\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 4.1. La suma de la serie\r\n--    1\/1^2 + 1\/2^2 + 1\/3^2 + 1\/4^2 + ...\r\n-- es pi^2\/6. Por tanto, pi se puede aproximar mediante la ra\u00edz cuadrada\r\n-- de 6 por la suma de la serie.\r\n-- \r\n-- Definir, por comprensi\u00f3n, la funci\u00f3n aproximaPiC tal que \r\n-- (aproximaPiC n) es la aproximaci\u00f3n  de pi obtenida mediante n\r\n-- t\u00e9rminos de la serie. Por ejemplo,  \r\n--    aproximaPiC 4    == sqrt(6*(1\/1^2 + 1\/2^2 + 1\/3^2 + 1\/4^2))\r\n--                     == 2.9226129861250305\r\n--    aproximaPiC 1000 == 3.1406380562059946\r\n-- ---------------------------------------------------------------------\r\n\r\naproximaPiC n = sqrt(6*sum [1\/x^2 | x <- [1..n]])\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 4.2. Definir, por recursi\u00f3n, la funci\u00f3n aproximaPiR tal\r\n-- que (aproximaPiR n) es la aproximaci\u00f3n  de pi obtenida mediante n\r\n-- t\u00e9rminos de la serie. Por ejemplo,  \r\n--    aproximaPiR 4    == sqrt(6*(1\/1^2 + 1\/2^2 + 1\/3^2 + 1\/4^2))\r\n--                     == 2.9226129861250305\r\n--    aproximaPiR 1000 == 3.1406380562059946\r\n-- ---------------------------------------------------------------------\r\n\r\naproximaPiR n = sqrt(6*aproximaPiR' n)\r\n\r\naproximaPiR' 1 = 1\r\naproximaPiR' n = 1\/n^2 + aproximaPiR' (n-1)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 5.1. Definir por recursi\u00f3n la funci\u00f3n \r\n--    sustituyeImpar :: [Int] -> [Int]\r\n-- tal que (sustituyeImpar xs) es la lista obtenida sustituyendo cada\r\n-- n\u00famero impar de xs por el siguiente n\u00famero par. Por ejemplo,\r\n--    sustituyeImpar [2,5,7,4]  ==  [2,6,8,4]\r\n-- --------------------------------------------------------------------- \r\n\r\nsustituyeImpar :: [Int] -> [Int]\r\nsustituyeImpar []     = []\r\nsustituyeImpar (x:xs) | odd x     = (x+1): sustituyeImpar xs\r\n                      | otherwise = x:sustituyeImpar xs\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 5.2. Comprobar con QuickChek la siguiente propiedad: para\r\n-- cualquier lista de n\u00fameros enteros xs, todos los elementos de la\r\n-- lista (sustituyeImpar xs) son n\u00fameros pares. \r\n-- ---------------------------------------------------------------------\r\n\r\n-- La propiedad es\r\nprop_sustituyeImpar :: [Int] -> Bool\r\nprop_sustituyeImpar xs = and [even x | x <- sustituyeImpar xs]\r\n\r\n-- La comprobaci\u00f3n es\r\n--    ghci> quickCheck prop_sustituyeImpar\r\n--    +++ OK, passed 100 tests.\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 ejercicios 4 y 5 de la 10\u00aa relaci\u00f3n y 1 a 5 de la 11\u00aa relaci\u00f3n en las que se presentan ejercicios con dos definiciones (una por recursi\u00f3n y otra por comprensi\u00f3n) y la comprobaci\u00f3n de&#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":[1],"tags":[298],"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\/2392"}],"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=2392"}],"version-history":[{"count":2,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/2392\/revisions"}],"predecessor-version":[{"id":2727,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/2392\/revisions\/2727"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=2392"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=2392"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=2392"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}