{"id":3880,"date":"2013-12-03T18:26:03","date_gmt":"2013-12-03T17:26:03","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=3880"},"modified":"2013-12-03T18:26:52","modified_gmt":"2013-12-03T17:26:52","slug":"i1m2013-ejercicios-de-definiciones-por-recursion-y-comprension-2","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2013-ejercicios-de-definiciones-por-recursion-y-comprension-2\/","title":{"rendered":"I1M2013: Ejercicios de definiciones por recursi\u00f3n y comprensi\u00f3n (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 17 de la 10\u00aa relaci\u00f3n y los de la 11\u00aa. En ambas relaciones se proponen 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 6 a 17 de la relaci\u00f3n 10 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\nimport Data.List\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 6. Definir la funci\u00f3n \r\n--    esDigito :: Integer -> Integer -> Bool\r\n-- tal que (esDigito x n) se verifica si x es un d\u00edgito de n. Por\r\n-- ejemplo, \r\n--    esDigito 4 1041  ==  True\r\n--    esDigito 3 1041  ==  False\r\n-- ---------------------------------------------------------------------\r\n\r\nesDigito :: Integer -> Integer -> Bool\r\nesDigito x n = x `elem` digitosC n\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 7. Definir la funci\u00f3n\r\n--    numeroDeDigitos :: Integer -> Integer\r\n-- tal que (numeroDeDigitos x) es el n\u00famero de d\u00edgitos de x. Por ejemplo,\r\n--    numeroDeDigitos 34047  ==  5\r\n-- ---------------------------------------------------------------------\r\n\r\n-- 1\u00aa definici\u00f3n:\r\nnumeroDeDigitos :: Integer -> Int\r\nnumeroDeDigitos x = length (digitosC x)\r\n\r\n-- 2\u00aa definici\u00f3n:\r\nnumeroDeDigitos2 :: Integer -> Int\r\nnumeroDeDigitos2 x = length (show x)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 8.1. Definir, por recursi\u00f3n, la funci\u00f3n \r\n--    listaNumeroR :: [Integer] -> Integer\r\n-- tal que (listaNumeroR xs) es el n\u00famero formado por los d\u00edgitos xs. Por\r\n-- ejemplo, \r\n--    listaNumeroR [5]        == 5\r\n--    listaNumeroR [1,3,4,7]  == 1347\r\n--    listaNumeroR [0,0,1]    == 1\r\n-- ---------------------------------------------------------------------\r\n\r\nlistaNumeroR :: [Integer] -> Integer\r\nlistaNumeroR xs = listaNumeroR' (reverse xs)\r\n\r\nlistaNumeroR' :: [Integer] -> Integer\r\nlistaNumeroR' [x]    = x\r\nlistaNumeroR' (x:xs) = x + 10 * (listaNumeroR' xs)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 8.2. Definir, por comprensi\u00f3n, la funci\u00f3n \r\n--    listaNumeroC :: [Integer] -> Integer\r\n-- tal que (listaNumeroC xs) es el n\u00famero formado por los d\u00edgitos xs. Por\r\n-- ejemplo, \r\n--    listaNumeroC [5]        == 5\r\n--    listaNumeroC [1,3,4,7]  == 1347\r\n--    listaNumeroC [0,0,1]    == 1\r\n-- ---------------------------------------------------------------------\r\n\r\nlistaNumeroC :: [Integer] -> Integer\r\nlistaNumeroC xs = sum [y*10^n | (y,n) <- zip (reverse xs) [0..]]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 9.1. Definir, por recursi\u00f3n, la funci\u00f3n \r\n--    pegaNumerosR :: Integer -> Integer -> Integer\r\n-- tal que (pegaNumerosR x y) es el n\u00famero resultante de \"pegar\" los\r\n-- n\u00fameros x e y. Por ejemplo, \r\n--    pegaNumerosR 12 987   ==  12987\r\n--    pegaNumerosR 1204 7   ==  12047\r\n--    pegaNumerosR 100 100  ==  100100\r\n-- ---------------------------------------------------------------------\r\n\r\npegaNumerosR :: Integer -> Integer -> Integer\r\npegaNumerosR x y\r\n    | y < 10    = 10*x+y\r\n    | otherwise = 10 * pegaNumerosR x (y `div` 10) + (y `mod` 10)  \r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 9.2. Definir, sin usar recursi\u00f3n, la funci\u00f3n \r\n--    pegaNumerosNR :: Integer -> Integer -> Integer\r\n-- tal que (pegaNumerosNR x y) es el n\u00famero resultante de \"pegar\" los\r\n-- n\u00fameros x e y. Por ejemplo, \r\n--    pegaNumerosNR 12 987   ==  12987\r\n--    pegaNumerosNR 1204 7   ==  12047\r\n--    pegaNumerosNR 100 100  ==  100100\r\n-- ---------------------------------------------------------------------\r\n\r\npegaNumerosNR :: Integer -> Integer -> Integer\r\npegaNumerosNR x y = listaNumeroC (digitosC x ++ digitosC y)\r\n\r\n-- Otra definici\u00f3n es\r\npegaNumerosNR2 :: Integer -> Integer -> Integer\r\npegaNumerosNR2 x y = (x * (10^(numeroDeDigitos y))) + y\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 9.3. Comprobar con QuickCheck que las funciones\r\n-- pegaNumerosR y pegaNumerosNR son equivalentes.\r\n-- ---------------------------------------------------------------------\r\n\r\n-- La propiedad es\r\nprop_pegaNumeros :: Integer -> Integer -> Property\r\nprop_pegaNumeros x y =\r\n    x >= 0 && y >= 0 ==>\r\n    pegaNumerosR x y == pegaNumerosNR x y\r\n\r\n-- La comprobaci\u00f3n es\r\n--    *Main> quickCheck prop_pegaNumeros\r\n--    +++ OK, passed 100 tests.\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 10.1. Definir, por recursi\u00f3n, la funci\u00f3n \r\n--    primerDigitoR :: Integer -> Integer\r\n-- tal que (primerDigitoR n) es el primer d\u00edgito de n. Por ejemplo, \r\n--    primerDigitoR 425  ==  4\r\n-- ---------------------------------------------------------------------\r\n\r\nprimerDigitoR :: Integer -> Integer\r\nprimerDigitoR n \r\n    | n < 10    = n\r\n    | otherwise = primerDigitoR (n `div` 10)\r\n  \r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 10.2. Definir, sin usar recursi\u00f3n, la funci\u00f3n \r\n--    primerDigitoNR :: Integer -> Integer\r\n-- tal que (primerDigitoNR n) es la primera digito de n. Por ejemplo, \r\n--    primerDigitoNR 425  ==  4\r\n-- ---------------------------------------------------------------------\r\n\r\nprimerDigitoNR :: Integer -> Integer\r\nprimerDigitoNR n = head (digitosC n)\r\n\r\n-- Otra definici\u00f3 equivalente es\r\nprimerDigitoNR2 :: Integer -> Integer\r\nprimerDigitoNR2 n = n `div` 10^((numeroDeDigitos n)-1)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 10.3. Comprobar con QuickCheck que las funciones\r\n-- primerDigitoR y primerDigitoNR son equivalentes.\r\n-- ---------------------------------------------------------------------\r\n\r\n-- La propiedad es\r\nprop_primerDigito :: Integer -> Property\r\nprop_primerDigito x =\r\n    x >= 0 ==>\r\n    primerDigitoR x == primerDigitoNR x\r\n\r\n-- La comprobaci\u00f3n es\r\n--    *Main> quickCheck prop_primerDigito\r\n--    +++ OK, passed 100 tests.\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 11. Definir la funci\u00f3n \r\n--    ultimoDigito :: Integer -> Integer \r\n-- tal que (ultimoDigito n) es el \u00faltimo d\u00edgito de n. Por ejemplo, \r\n--    ultimoDigito 425  ==  5\r\n-- ---------------------------------------------------------------------\r\n\r\nultimoDigito :: Integer -> Integer \r\nultimoDigito n = n `rem` 10\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 12.1. Definir la funci\u00f3n \r\n--    inverso :: Integer -> Integer\r\n-- tal que (inverso n) es el n\u00famero obtenido escribiendo los d\u00edgitos de n\r\n-- en orden inverso. Por ejemplo, \r\n--    inverso 42578  ==  87524\r\n--    inverso 203    ==    302\r\n-- ---------------------------------------------------------------------\r\n\r\ninverso :: Integer -> Integer\r\ninverso n = listaNumeroC (reverse (digitosC n))\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 12.2. Definir, usando show y read, la funci\u00f3n \r\n--    inverso' :: Integer -> Integer\r\n-- tal que (inverso' n) es el n\u00famero obtenido escribiendo los d\u00edgitos de n\r\n-- en orden inverso'. Por ejemplo, \r\n--    inverso' 42578  ==  87524\r\n--    inverso' 203    ==    302\r\n-- ---------------------------------------------------------------------\r\n\r\ninverso' :: Integer -> Integer\r\ninverso' n = read (reverse (show n))\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 12.3. Comprobar con QuickCheck que las funciones\r\n-- inverso e inverso' son equivalentes.\r\n-- ---------------------------------------------------------------------\r\n\r\n-- La propiedad es\r\nprop_inverso :: Integer -> Property\r\nprop_inverso n =\r\n    n >= 0 ==>\r\n    inverso n == inverso' n\r\n\r\n-- La comprobaci\u00f3n es\r\n--    *Main> quickCheck prop_inverso\r\n--    +++ OK, passed 100 tests.\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 13. Definir la funci\u00f3n \r\n--    capicua :: Integer -> Bool\r\n-- tal que (capicua n) se verifica si los d\u00edgitos que n son las mismos\r\n-- de izquierda a derecha que de derecha a izquierda. Por ejemplo,\r\n--    capicua 1234  =  False\r\n--    capicua 1221  =  True\r\n--    capicua 4     =  True\r\n-- ---------------------------------------------------------------------\r\n\r\ncapicua :: Integer -> Bool\r\ncapicua n = n == inverso n\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 14. (Problema 16 del proyecto Euler) El problema se\r\n-- encuentra en http:\/\/goo.gl\/4uWh y consiste en calcular la suma de los\r\n-- d\u00edgitos de 2^1000. Lo resolveremos mediante los distintos apartados de\r\n-- este ejercicio.  \r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 14.1. Definir la funci\u00f3n\r\n--    euler16 :: Integer -> Integer\r\n-- tal que (euler16 n) es la suma de los d\u00edgitos de 2^n. Por ejemplo,\r\n--    euler16 4  ==  7\r\n-- ---------------------------------------------------------------------\r\n\r\neuler16 :: Integer -> Integer\r\neuler16 n = sumaDigitosNR (2^n)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 14.2. Calcular la suma de los d\u00edgitos de 2^1000.\r\n-- ---------------------------------------------------------------------\r\n\r\n-- El c\u00e1lculo es\r\n--    *Main> euler16 1000\r\n--    1366\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 15.1. En el enunciado de uno de los problemas de las\r\n-- Olimpiadas matem\u00e1ticas de Brasil se define el primitivo de un n\u00famero\r\n-- como sigue: \r\n--    Dado un n\u00famero natural N, multiplicamos todos sus d\u00edgitos,\r\n--    repetimos este procedimiento hasta que quede un solo d\u00edgito al\r\n--    cual llamamos primitivo de N. Por ejemplo para 327: 3x2x7 = 42 y \r\n--    4x2 = 8. Por lo tanto, el primitivo de 327 es 8.\r\n--\r\n-- Definir la funci\u00f3n \r\n--    primitivo :: Integer -> Integer\r\n-- tal que (primitivo n) es el primitivo de n. Por ejemplo.\r\n--    primitivo 327  ==  8\r\n-- ---------------------------------------------------------------------\r\n\r\nprimitivo :: Integer -> Integer\r\nprimitivo n | n < 10    = n\r\n            | otherwise = primitivo (producto n)\r\n\r\n-- (producto n) es el producto de las cifras de n. Por ejemplo,\r\n--    producto 327  ==  42\r\nproducto :: Integer -> Integer\r\nproducto n = product (digitosC n) \r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 15.2. Comprobar con QuickCheck si el primitivo de cualquier\r\n-- n\u00famero natural n coincide con el se su inverso. En caso de que falle,\r\n-- a\u00f1adir las m\u00ednimas condiciones para que se verifique.\r\n-- --------------------------------------------------------------------- \r\n\r\n-- La propiedad es\r\nprop_primitivo1 :: Integer -> Property\r\nprop_primitivo1 n = \r\n    n >= 0 ==> primitivo n == primitivo (inverso n)\r\n\r\n-- La comprobaci\u00f3n falla\r\n--    ghci> quickCheck prop_primitivo1\r\n--    *** Failed! Falsifiable (after 19 tests): \r\n--    10\r\n-- En efecto,\r\n--    ghci> primitivo 10\r\n--    0\r\n--    ghci> inverso 10\r\n--    1\r\n--    ghci> primitivo 1\r\n--    1\r\n\r\n-- Le a\u00f1adimos la condici\u00f3n de que la \u00faltima cifra se distinta de 0.\r\nprop_primitivo2 :: Integer -> Property\r\nprop_primitivo2 n = \r\n    n >= 0 && n `rem` 10 \/= 0 ==> \r\n    primitivo n == primitivo (inverso n)\r\n\r\n-- La comprobaci\u00f3n es\r\n--    ghci> quickCheck prop_primitivo2\r\n--    +++ OK, passed 100 tests.\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 16.1. Dos n\u00fameros son equivalentes si la media de sus\r\n-- d\u00edgitos son iguales. Por ejemplo, 3205 y 41 son equivalentes ya que \r\n-- (3+2+0+5)\/4 = (4+1)\/2. Definir la funci\u00f3n \r\n--    equivalentes :: Integer -> Integer -> Bool\r\n-- tal que (equivalentes x y) se verifica si los n\u00fameros x e y son\r\n-- equivalentes. Por ejemplo,\r\n--    equivalentes 3205 41  ==  True\r\n--    equivalentes 3205 25  ==  False\r\n-- ---------------------------------------------------------------------\r\n\r\nequivalentes :: Integer -> Integer -> Bool\r\nequivalentes x y = media (digitosC x) == media (digitosC y)\r\n\r\n-- (media xs) es la media de la lista xs. Por ejemplo,\r\n--    media [3,2,0,5]  ==  2.5\r\nmedia :: [Integer] -> Float\r\nmedia xs = (fromIntegral (sum xs)) \/ (fromIntegral (length xs))\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 16.2. Comprobar con QuickCheck que equivalentes cumple la\r\n-- propiedad reflexiva.\r\n-- ---------------------------------------------------------------------\r\n\r\n-- La propiedad es\r\nprop_equivalentesR :: Integer -> Property\r\nprop_equivalentesR x = \r\n    x >= 0 ==> equivalentes x x \r\n\r\n-- La comprobaci\u00f3n es\r\n--    ghci> quickCheck prop_equivalentesR\r\n--    +++ OK, passed 100 tests.\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 16.3. Comprobar con QuickCheck que equivalentes cumple la\r\n-- propiedad sim\u00e9trica.\r\n-- ---------------------------------------------------------------------\r\n\r\n-- La propiedad es\r\nprop_equivalentesS :: Integer -> Integer -> Property\r\nprop_equivalentesS x y = \r\n    x >= 0 && y >= 0 ==>\r\n    equivalentes x y == equivalentes y x\r\n\r\n-- La comprobaci\u00f3n es\r\n--    ghci> quickCheck prop_equivalentesS\r\n--    +++ OK, passed 100 tests.\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 16.4. Comprobar con QuickCheck que equivalentes cumple la\r\n-- propiedad transitiva.\r\n-- ---------------------------------------------------------------------\r\n\r\n-- La propiedad es\r\nprop_equivalentesT :: Integer -> Integer -> Integer -> Property\r\nprop_equivalentesT x y z = \r\n    x >= 0 && y >= 0  && z >= 0 && \r\n    equivalentes x y && equivalentes y z ==>\r\n    equivalentes x z\r\n\r\n-- La comprobaci\u00f3n es\r\n--    ghci> quickCheck prop_equivalentesT\r\n--    *** Gave up! Passed only 2 tests.\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 17. Un n\u00famero x es especial si el n\u00famero de ocurrencia de\r\n-- cada d\u00edgito d de x en x^2 es el doble del n\u00famero de ocurrencia de d\r\n-- en x. Por ejemplo, 72576 es especial porque tiene un 2, un 5, un 6 y\r\n-- dos 7 y su cuadrado es 5267275776 que tiene exactamente dos 2, dos 5,\r\n-- dos 6 y cuatro 7.\r\n-- \r\n-- Definir la funci\u00f3n\r\n--    especial :: Integer -> Bool\r\n-- tal que (especial x) se verifica si x es un n\u00famero especial. Por\r\n-- ejemplo,\r\n--    especial 72576  ==  True\r\n--    especial 12     ==  False\r\n-- Calcular el menor n\u00famero especial mayor que 72576.\r\n-- ---------------------------------------------------------------------\r\n\r\nespecial :: Integer -> Bool\r\nespecial x =\r\n    sort (ys ++ ys) == sort (show (x^2))\r\n    where ys = show x\r\n\r\n-- El c\u00e1lculo es\r\n--    ghci> head [x | x <- [72577..], especial x]\r\n--    406512\r\n<\/pre>\n<p>Los ejercicios la relaci\u00f3n 11 y soluciones se muestran a continuaci\u00f3n<br \/>\n<!--more--><\/p>\n<pre lang=\"haskell\">\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.1. Definir, por comprensi\u00f3n, la funci\u00f3n\r\n--    cuadradosC :: [Integer] -> [Integer]\r\n-- tal que (cuadradosC xs) es la lista de los cuadrados de xs. Por\r\n-- ejemplo, \r\n--    cuadradosC [1,2,3]  ==  [1,4,9]\r\n-- ---------------------------------------------------------------------\r\n\r\ncuadradosC :: [Integer] -> [Integer]\r\ncuadradosC xs = [x^2 | x <- xs]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.2. Definir, por recursi\u00f3n, la funci\u00f3n\r\n--    cuadradosR :: [Integer] -> [Integer]\r\n-- tal que (cuadradosR xs) es la lista de los cuadrados de xs. Por\r\n-- ejemplo, \r\n--    cuadradosR [1,2,3]  ==  [1,4,9]\r\n-- ---------------------------------------------------------------------\r\n\r\ncuadradosR :: [Integer] -> [Integer]\r\ncuadradosR []     = []\r\ncuadradosR (x:xs) = x^2 : cuadradosR xs\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2.1. Definir, por comprensi\u00f3n, la funci\u00f3n\r\n--    imparesC :: [Integer] -> [Integer]\r\n-- tal que (imparesC xs) es la lista de los n\u00fameros impares de xs. Por\r\n-- ejemplo, \r\n--    imparesC [1,2,3]  ==  [1,3]\r\n-- ---------------------------------------------------------------------\r\n\r\nimparesC :: [Integer] -> [Integer]\r\nimparesC xs = [x | x <- xs, odd x]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2.2. Definir, por recursi\u00f3n, la funci\u00f3n\r\n--    imparesR :: [Integer] -> [Integer]\r\n-- tal que (imparesR xs) es la lista de los n\u00fameros impares de xs. Por\r\n-- ejemplo, \r\n--    imparesR [1,2,3]  ==  [1,3]\r\n-- ---------------------------------------------------------------------\r\n\r\nimparesR :: [Integer] -> [Integer]\r\nimparesR [] = []\r\nimparesR (x:xs) | odd x     = x : imparesR xs\r\n                | otherwise = imparesR xs\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 3.1. Definir, por comprensi\u00f3n, la funci\u00f3n\r\n--    imparesCuadradosC :: [Integer] -> [Integer]\r\n-- tal que (imparesCuadradosC xs) es la lista de los cuadrados de los\r\n-- n\u00fameros impares de xs. Por ejemplo, \r\n--    imparesCuadradosC [1,2,3]  ==  [1,9]\r\n-- ---------------------------------------------------------------------\r\n\r\nimparesCuadradosC :: [Integer] -> [Integer]\r\nimparesCuadradosC xs = [x^2 | x <- xs, odd x]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 3.2. Definir, por recursi\u00f3n, la funci\u00f3n\r\n--    imparesCuadradosR :: [Integer] -> [Integer]\r\n-- tal que (imparesCuadradosR xs) es la lista de los cuadrados de los\r\n-- n\u00fameros impares de xs. Por ejemplo, \r\n--    imparesCuadradosR [1,2,3]  ==  [1,9]\r\n-- ---------------------------------------------------------------------\r\n\r\nimparesCuadradosR :: [Integer] -> [Integer]\r\nimparesCuadradosR []                 = []\r\nimparesCuadradosR (x:xs) | odd x     = x^2 : imparesCuadradosR xs\r\n                         | otherwise = imparesCuadradosR xs\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","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 17 de la 10\u00aa relaci\u00f3n y los de la 11\u00aa. En ambas relaciones se proponen ejercicios con dos definiciones (una por recursi\u00f3n y otra por comprensi\u00f3n) y la comprobaci\u00f3n de la&#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,126],"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\/3880"}],"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=3880"}],"version-history":[{"count":2,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/3880\/revisions"}],"predecessor-version":[{"id":3882,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/3880\/revisions\/3882"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=3880"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=3880"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=3880"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}