{"id":5806,"date":"2017-10-25T14:01:34","date_gmt":"2017-10-25T12:01:34","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=5806"},"modified":"2017-10-26T11:02:29","modified_gmt":"2017-10-26T09:02:29","slug":"i1m2017-ejercicios-de-definiciones-por-recursion-2","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2017-ejercicios-de-definiciones-por-recursion-2\/","title":{"rendered":"I1M2017: Ejercicios de definiciones por recursi\u00f3n (2)"},"content":{"rendered":"<p>En la segunda parte de la clase de hoy del curso de <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-17\">Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas<\/a> se ha comentado las soluciones de los ejercicios de la 4\u00aa relaci\u00f3n sobre definiciones por recursi\u00f3n iniciada en la <a href=\"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2017-ejercicios-de-definiciones-por-recursion-1\/\">clase anterior<\/a><\/p>\n<p>Los ejercicios y su soluci\u00f3n se muestran a continuaci\u00f3n<br \/>\n<!--more--><\/p>\n<pre lang=\"haskell\">\n-- ---------------------------------------------------------------------\n-- Ejercicio 4.1. Definir por recursi\u00f3n la funci\u00f3n\n--    concatenaListas :: [[a]] -> [a]\n-- tal que (concatenaListas xss) es la lista obtenida concatenando las\n-- listas de xss. Por ejemplo,\n--    concatenaListas [[1..3],[5..7],[8..10]]  ==  [1,2,3,5,6,7,8,9,10]\n-- ---------------------------------------------------------------------\n \nconcatenaListas :: [[a]] -> [a]\nconcatenaListas []       = []\nconcatenaListas (xs:xss) = xs ++ concatenaListas xss\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 4.2. Comprobar con QuickCheck que concatenaListas es\n-- equivalente a concat. \n-- ---------------------------------------------------------------------\n\n-- La propiedad es\nprop_concat :: Eq a => [[a]] -> Bool\nprop_concat xss = concatenaListas xss == concat xss\n\n-- La comprobaci\u00f3n es\n--    ghci> quickCheck prop_concat\n--    +++ OK, passed 100 tests.\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 5.1. Definir por recursi\u00f3n la funci\u00f3n\n--    coge :: Int -> [a] -> [a]\n-- tal que (coge n xs) es la lista de los n primeros elementos de\n-- xs. Por ejemplo, \n--    coge 3 [4..12]  =>  [4,5,6]\n-- ---------------------------------------------------------------------\n\ncoge :: Int -> [a] -> [a]\ncoge n _  | n <= 0 = []\ncoge _ []          = []\ncoge n (x:xs)      = x : coge (n-1) xs\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 5.2. Comprobar con QuickCheck que coge es equivalente a\n-- take. \n-- ---------------------------------------------------------------------\n\n-- La propiedad es\nprop_coge :: Int -> [Int] -> Bool\nprop_coge n xs =\n  coge n xs == take n xs\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 6.1. Definir, por recursi\u00f3n, la funci\u00f3n \n--    sumaCuadradosR :: Integer -> Integer\n-- tal que (sumaCuadradosR n) es la suma de los cuadrados de los n\u00fameros\n-- de 1 a n. Por ejemplo, \n--    sumaCuadradosR 4  ==  30 \n-- ---------------------------------------------------------------------\n\nsumaCuadradosR :: Integer -> Integer\nsumaCuadradosR 0 = 0\nsumaCuadradosR n = n^2 + sumaCuadradosR (n-1) \n\n-- ---------------------------------------------------------------------\n-- Ejercicio 6.2. Comprobar con QuickCheck si sumaCuadradosR n es igual a\n-- n(n+1)(2n+1)\/6. \n-- ---------------------------------------------------------------------\n\n-- La propiedad es\nprop_SumaCuadrados :: Integer -> Property\nprop_SumaCuadrados n =\n  n >= 0 ==>\n    sumaCuadradosR n == n * (n+1) * (2*n+1) `div` 6  \n\n-- La comprobaci\u00f3n es\n--    ghci> quickCheck prop_SumaCuadrados\n--    OK, passed 100 tests.\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 6.3. Definir, por comprensi\u00f3n, la funci\u00f3n \n--    sumaCuadradosC :: Integer --> Integer\n-- tal que (sumaCuadradosC n) es la suma de los cuadrados de los n\u00fameros\n-- de 1 a n. Por ejemplo, \n--    sumaCuadradosC 4  ==  30 \n-- ---------------------------------------------------------------------\n\nsumaCuadradosC :: Integer -> Integer\nsumaCuadradosC n = sum [x^2 | x <- [1..n]]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 6.4. Comprobar con QuickCheck que las funciones\n-- sumaCuadradosR y sumaCuadradosC son equivalentes sobre los n\u00fameros\n-- naturales. \n-- ---------------------------------------------------------------------\n\n-- La propiedad es\nprop_sumaCuadradosR :: Integer -> Property\nprop_sumaCuadradosR n =\n    n >= 0 ==> sumaCuadradosR n == sumaCuadradosC n\n\n-- La comprobaci\u00f3n es\n--    ghci> quickCheck prop_sumaCuadrados\n--    +++ OK, passed 100 tests.\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 7.1. Definir, por recursi\u00f3n, la funci\u00f3n\n--    digitosR :: Integer -> [Integer]\n-- tal que (digitosR n) es la lista de los d\u00edgitos del n\u00famero n. Por\n-- ejemplo, \n--    digitosR 320274  ==  [3,2,0,2,7,4]\n-- ---------------------------------------------------------------------\n\ndigitosR :: Integer -> [Integer]\ndigitosR n = reverse (digitosR' n)\n\ndigitosR' :: Integer -> [Integer]\ndigitosR' n\n    | n < 10    = [n]\n    | otherwise = (n `rem` 10) : digitosR' (n `div` 10)\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 7.2. Definir, por comprensi\u00f3n, la funci\u00f3n\n--    digitosC :: Integer -> [Integer]\n-- tal que (digitosC n) es la lista de los d\u00edgitos del n\u00famero n. Por\n-- ejemplo, \n--    digitosC 320274  ==  [3,2,0,2,7,4]\n-- Indicaci\u00f3n: Usar las funciones show y read.\n-- ---------------------------------------------------------------------\n\ndigitosC :: Integer -> [Integer]\ndigitosC n = [read [x] | x <- show n]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 7.3. Comprobar con QuickCheck que las funciones digitosR y\n-- digitosC son equivalentes.\n-- ---------------------------------------------------------------------\n\n-- La propiedad es\nprop_digitos :: Integer -> Property\nprop_digitos n =\n    n >= 0 ==> \n    digitosR n == digitosC n\n  \n-- La comprobaci\u00f3n es\n--    ghci> quickCheck prop_digitos\n--    +++ OK, passed 100 tests.\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 8.1. Definir, por recursi\u00f3n, la funci\u00f3n \n--    sumaDigitosR :: Integer -> Integer\n-- tal que (sumaDigitosR n) es la suma de los d\u00edgitos de n. Por ejemplo,\n--    sumaDigitosR 3     ==  3\n--    sumaDigitosR 2454  == 15\n--    sumaDigitosR 20045 == 11\n-- ---------------------------------------------------------------------\n\nsumaDigitosR :: Integer -> Integer\nsumaDigitosR n\n    | n < 10    = n\n    | otherwise = n `rem` 10 + sumaDigitosR (n `div` 10)\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 8.2. Definir, sin usar recursi\u00f3n, la funci\u00f3n \n--    sumaDigitosNR :: Integer -> Integer\n-- tal que (sumaDigitosNR n) es la suma de los d\u00edgitos de n. Por ejemplo,\n--    sumaDigitosNR 3     ==  3\n--    sumaDigitosNR 2454  == 15\n--    sumaDigitosNR 20045 == 11\n-- ---------------------------------------------------------------------\n\nsumaDigitosNR :: Integer -> Integer\nsumaDigitosNR n = sum (digitosC n)\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 8.3. Comprobar con QuickCheck que las funciones sumaDigitosR\n-- y sumaDigitosNR son equivalentes.\n-- ---------------------------------------------------------------------\n\n-- La propiedad es\nprop_sumaDigitos :: Integer -> Property\nprop_sumaDigitos n =\n    n >= 0 ==>\n    sumaDigitosR n == sumaDigitosNR n\n\n-- La comprobaci\u00f3n es\n--    ghci> quickCheck prop_sumaDigitos\n--    +++ OK, passed 100 tests.\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 9.1. Definir, por recursi\u00f3n, la funci\u00f3n \n--    listaNumeroR :: [Integer] -> Integer\n-- tal que (listaNumeroR xs) es el n\u00famero formado por los d\u00edgitos xs. Por\n-- ejemplo, \n--    listaNumeroR [5]        == 5\n--    listaNumeroR [1,3,4,7]  == 1347\n--    listaNumeroR [0,0,1]    == 1\n-- ---------------------------------------------------------------------\n\nlistaNumeroR :: [Integer] -> Integer\nlistaNumeroR xs = listaNumeroR' (reverse xs)\n\nlistaNumeroR' :: [Integer] -> Integer\nlistaNumeroR' []     = 0\nlistaNumeroR' (x:xs) = x + 10 * listaNumeroR' xs\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 9.2. Definir, por comprensi\u00f3n, la funci\u00f3n \n--    listaNumeroC :: [Integer] -> Integer\n-- tal que (listaNumeroC xs) es el n\u00famero formado por los d\u00edgitos xs. Por\n-- ejemplo, \n--    listaNumeroC [5]        == 5\n--    listaNumeroC [1,3,4,7]  == 1347\n--    listaNumeroC [0,0,1]    == 1\n-- ---------------------------------------------------------------------\n\n-- 1\u00aa definici\u00f3n:\nlistaNumeroC :: [Integer] -> Integer\nlistaNumeroC xs = sum [y*10^n | (y,n) <- zip (reverse xs) [0..]]\n\n-- 2\u00aa definici\u00f3n:\nlistaNumeroC2 :: [Integer] -> Integer\nlistaNumeroC2 xs = read [x | x <- show xs, isDigit x]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 9.3. Comprobar con QuickCheck que las funciones\n-- listaNumeroR y listaNumeroC son equivalentes.\n-- ---------------------------------------------------------------------\n\n-- La propiedad es\nprop_listaNumero :: [Integer] -> Bool\nprop_listaNumero xs =\n    listaNumeroR xs == listaNumeroC xs\n\n-- La comprobaci\u00f3n es\n--    ghci> quickCheck prop_listaNumero\n--    +++ OK, passed 100 tests.\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 10.1. Definir, por recursi\u00f3n, la funci\u00f3n \n--    mayorExponenteR :: Integer -> Integer -> Integer \n-- tal que (mayorExponenteR a b) es el exponente de la mayor potencia de\n-- a que divide b. Por ejemplo,\n--    mayorExponenteR 2 8    ==  3\n--    mayorExponenteR 2 9    ==  0\n--    mayorExponenteR 5 100  ==  2\n--    mayorExponenteR 2 60   ==  2\n-- ---------------------------------------------------------------------\n\nmayorExponenteR :: Integer -> Integer -> Integer \nmayorExponenteR a b\n    | rem b a \/= 0 = 0\n    | otherwise    = 1 + mayorExponenteR a (b `div` a)\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 10.2. Definir, por comprensi\u00f3n, la funci\u00f3n \n--    mayorExponenteC :: Integer -> Integer -> Integer \n-- tal que (mayorExponenteC a b) es el exponente de la mayor potencia de\n-- a que divide a b. Por ejemplo,\n--    mayorExponenteC 2 8    ==  3\n--    mayorExponenteC 5 100  ==  2\n--    mayorExponenteC 5 101  ==  0\n-- ---------------------------------------------------------------------\n\nmayorExponenteC :: Integer -> Integer -> Integer\nmayorExponenteC a b = head [x-1 | x <- [0..], mod b (a^x) \/= 0]\n<\/pre>\n","protected":false},"excerpt":{"rendered":"<p>En la segunda parte de la clase de hoy del curso de Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas se ha comentado las soluciones de los ejercicios de la 4\u00aa relaci\u00f3n sobre definiciones por recursi\u00f3n iniciada en la clase anterior Los ejercicios y su soluci\u00f3n se muestran a continuaci\u00f3n<\/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":[265],"tags":[270,267],"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\/5806"}],"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=5806"}],"version-history":[{"count":1,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/5806\/revisions"}],"predecessor-version":[{"id":5807,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/5806\/revisions\/5807"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=5806"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=5806"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=5806"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}