{"id":5579,"date":"2016-10-28T17:47:50","date_gmt":"2016-10-28T15:47:50","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=5579"},"modified":"2016-10-30T07:48:56","modified_gmt":"2016-10-30T06:48:56","slug":"i1m2016-ejercicios-de-definiciones-por-recursion-2","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2016-ejercicios-de-definiciones-por-recursion-2\/","title":{"rendered":"I1M2016: 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-16\">Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas<\/a> se han comentado las soluciones de los ejercicios de la 5\u00aa relaci\u00f3n sobre definiciones por recursi\u00f3n.<\/p>\n<p>Los ejercicios y su soluci\u00f3n se muestran a continuaci\u00f3n<br \/>\n<!--more--><\/p>\n<pre lang=\"haskell\">\n-- ---------------------------------------------------------------------\n-- Introducci\u00f3n                                                       --\n-- ---------------------------------------------------------------------\n\n-- En esta relaci\u00f3n se presentan ejercicios con definiciones por\n-- recursi\u00f3n correspondientes al tema 6 cuyas transparencias se \n-- encuentran en  \n--    http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-16\/temas\/tema-6.html\n \n-- ---------------------------------------------------------------------\n-- Importaci\u00f3n de librer\u00edas auxiliares                                --\n-- ---------------------------------------------------------------------\n\nimport Test.QuickCheck\nimport Data.Char\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 1.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 1.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 1.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 1.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 2.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' n\n    | n < 10    = [n]\n    | otherwise = (n `rem` 10) : digitosR' (n `div` 10)\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 2.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 2.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 3.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 3.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 3.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 4.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 4.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 4.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 5.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 5.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 han comentado las soluciones de los ejercicios de la 5\u00aa relaci\u00f3n sobre definiciones por recursi\u00f3n. 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":[260],"tags":[270,313],"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\/5579"}],"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=5579"}],"version-history":[{"count":1,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/5579\/revisions"}],"predecessor-version":[{"id":5580,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/5579\/revisions\/5580"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=5579"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=5579"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=5579"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}