{"id":5546,"date":"2016-10-14T11:41:44","date_gmt":"2016-10-14T09:41:44","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=5546"},"modified":"2016-10-15T11:45:26","modified_gmt":"2016-10-15T09:45:26","slug":"i1m2016-ejercicios-de-definiciones-por-comprension-1","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2016-ejercicios-de-definiciones-por-comprension-1\/","title":{"rendered":"I1M2016: Ejercicios de definiciones por comprensi\u00f3n (1)"},"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 6 primeros ejercicios de la 3\u00aa relaci\u00f3n sobre definiciones por comprensi\u00f3n.<\/p>\n<p>Los ejercicios y su soluci\u00f3n se muestran a continuaci\u00f3n<br \/>\n<!--more--><\/p>\n<pre lang=\"haskell\">\n-- I1M 2016-17: Rel_4.hs (5 de Octubre de 2016)\n-- Definiciones por comprensi\u00f3n\n-- Departamento de Ciencias de la Computaci\u00f3n e I.A.\n-- Universidad de Sevilla\n-- =====================================================================\n\n-- ---------------------------------------------------------------------\n-- Introducci\u00f3n                                                       --\n-- ---------------------------------------------------------------------\n\n-- En esta relaci\u00f3n se presentan ejercicios con definiciones por\n-- comprensi\u00f3n correspondientes al tema 5 que se encuentra\n--    http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-16\/temas\/tema-5.html\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 1. Definir, por comprensi\u00f3n, la funci\u00f3n \n--    sumaDeCuadrados :: Integer -> Integer \n-- tal que (sumaDeCuadrados n) es la suma de los cuadrados de los\n-- primeros n n\u00fameros; es decir, 1^2 + 2^2 + ... + n^2. Por ejemplo,\n--    sumaDeCuadrados 3    ==  14\n--    sumaDeCuadrados 100  ==  338350\n-- ---------------------------------------------------------------------\n\nsumaDeCuadrados :: Integer -> Integer \nsumaDeCuadrados n = sum [x^2 | x <- [1..n]]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 2. Definir por comprensi\u00f3n la funci\u00f3n \n--    replica :: Int -> a -> [a]\n-- tal que (replica n x) es la lista formada por n copias del elemento\n-- x. Por ejemplo,  \n--    replica 4 7     ==  [7,7,7,7]\n--    replica 3 True  ==  [True, True, True]\n-- Nota: La funci\u00f3n replica es equivalente a la predefinida replicate.\n-- ---------------------------------------------------------------------\n\nreplica :: Int -> a -> [a]\nreplica n x = [x | _ <- [1..n]]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 3.1. Definir la funci\u00f3n \n--    suma :: Integer -> Integer\n-- tal (suma n) es la suma de los n primeros n\u00fameros. Por ejemplo,\n--    suma 3  ==  6\n-- ---------------------------------------------------------------------\n\nsuma :: Integer -> Integer\nsuma n = sum [1..n]\n\n-- Otra definici\u00f3n m\u00e1s eficiente es\nsuma2 :: Integer -> Integer\nsuma2 n = (1+n)*n `div` 2\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 3.2. Los tri\u00e1ngulos aritm\u00e9ticos se forman como sigue\n--     1\n--     2  3\n--     4  5  6\n--     7  8  9 10\n--    11 12 13 14 15\n--    16 17 18 19 20 21\n-- Definir la funci\u00f3n\n--    linea :: Integer -> [Integer]\n-- tal que (linea n) es la l\u00ednea n-\u00e9sima de los tri\u00e1ngulos\n-- aritm\u00e9ticos. Por ejemplo,  \n--    linea 4  ==  [7,8,9,10]\n--    linea 5  ==  [11,12,13,14,15]\n-- ---------------------------------------------------------------------\n\nlinea :: Integer -> [Integer]\nlinea n = [suma (n-1)+1..suma n]\n\n-- La definici\u00f3n puede mejorarse\nlinea2 :: Integer -> [Integer]\nlinea2 n = [s+1..s+n]\n  where s = suma (n-1)\n\n-- Una variante m\u00e1s eficiente es \nlinea3 :: Integer -> [Integer]\nlinea3 n = [s+1..s+n]\n  where s = suma2 (n-1)\n\n-- La mejora de la eficiencia se puede observar como sigue:\n--    ghci> :set +s\n--    ghci> head (linea 1000000)\n--    499999500001\n--    (17.94 secs, 309207420 bytes)\n--    ghci> head (linea3 1000000)\n--    499999500001\n--    (0.01 secs, 525496 bytes)\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 3.3. Definir la funci\u00f3n \n--    triangulo :: Integer -> [[Integer]]\n-- tal que (triangulo n) es el tri\u00e1ngulo aritm\u00e9tico de altura n. Por\n-- ejemplo, \n--    triangulo 3  ==  [[1],[2,3],[4,5,6]]\n--    triangulo 4  ==  [[1],[2,3],[4,5,6],[7,8,9,10]]\n-- ---------------------------------------------------------------------\n\ntriangulo :: Integer -> [[Integer]]\ntriangulo n = [linea m | m <- [1..n]]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 4. Un entero positivo es perfecto si es igual a la suma de\n-- sus factores, excluyendo el propio n\u00famero. \n-- \n-- Definir por comprensi\u00f3n la funci\u00f3n \n--    perfectos :: Int -> [Int]\n-- tal que (perfectos n) es la lista de todos los n\u00fameros perfectos\n-- menores que n. Por ejemplo,  \n--    perfectos 500  ==  [6,28,496]\n-- Indicaci\u00f3n: Usar la funci\u00f3n factores del tema 5.\n-- ---------------------------------------------------------------------\n\n-- La funci\u00f3n factores del tema es\nfactores :: Int -> [Int]\nfactores n = [x | x <- [1..n], n `mod` x == 0]\n\n-- La definici\u00f3n es\nperfectos :: Int -> [Int]\nperfectos n = [x | x <- [1..n], sum (init (factores x)) == x]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 5.1. Un n\u00famero natural n se denomina abundante si es menor\n-- que la suma de sus divisores propios. Por ejemplo, 12 y 30 son\n-- abundantes pero 5 y 28 no lo son.\n-- \n-- Definir la funci\u00f3n \n--    numeroAbundante :: Int -> Bool\n-- tal que (numeroAbundante n) se verifica si n es un n\u00famero\n-- abundante. Por ejemplo,  \n--    numeroAbundante 5  == False\n--    numeroAbundante 12 == True\n--    numeroAbundante 28 == False\n--    numeroAbundante 30 == True\n-- ---------------------------------------------------------------------\n\ndivisores :: Int -> [Int]\ndivisores n = [m | m <- [1..n-1], n `mod` m == 0]\n\nnumeroAbundante :: Int -> Bool\nnumeroAbundante n = n < sum (divisores n)\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 5.2. Definir la funci\u00f3n  \n--    numerosAbundantesMenores :: Int -> [Int]\n-- tal que (numerosAbundantesMenores n) es la lista de n\u00fameros\n-- abundantes menores o iguales que n. Por ejemplo,\n--    numerosAbundantesMenores 50  ==  [12,18,20,24,30,36,40,42,48]\n-- ---------------------------------------------------------------------\n\nnumerosAbundantesMenores :: Int -> [Int]\nnumerosAbundantesMenores n = [x | x <- [1..n], numeroAbundante x]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 5.3. Definir la funci\u00f3n \n--    todosPares :: Int -> Bool\n-- tal que (todosPares n) se verifica si todos los n\u00fameros abundantes\n-- menores o iguales que n son pares. Por ejemplo,\n--    todosPares 10    ==  True\n--    todosPares 100   ==  True\n--    todosPares 1000  ==  False\n-- ---------------------------------------------------------------------\n\ntodosPares :: Int -> Bool\ntodosPares n = and [even x | x <- numerosAbundantesMenores n]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 5.4. Definir la constante \n--    primerAbundanteImpar :: Int\n-- que calcule el primer n\u00famero natural abundante impar. Determinar el\n-- valor de dicho n\u00famero.\n-- ---------------------------------------------------------------------\n\nprimerAbundanteImpar :: Int\nprimerAbundanteImpar = head [x | x <- [1,3..], numeroAbundante x]\n\n-- Su c\u00e1lculo es\n--    ghci> primerAbundanteImpar\n--    945\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 6 (Problema 1 del proyecto Euler) Definir la funci\u00f3n \n--    euler1 :: Int -> Int\n-- tal que (euler1 n) es la suma de todos los m\u00faltiplos de 3 \u00f3 5 menores\n-- que n. Por ejemplo,\n--    euler1 10  ==  23\n-- \n-- Calcular la suma de todos los m\u00faltiplos de 3 \u00f3 5 menores que 1000.\n-- ---------------------------------------------------------------------\n\neuler1 :: Int -> Int\neuler1 n = sum [x | x <- [1..n-1], multiplo x 3 || multiplo x 5]\n  where multiplo x y = mod x y == 0\n\n-- C\u00e1lculo:\n--    ghci> euler1 1000\n--    233168\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 6 primeros ejercicios de la 3\u00aa relaci\u00f3n sobre definiciones por comprensi\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\/5546"}],"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=5546"}],"version-history":[{"count":1,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/5546\/revisions"}],"predecessor-version":[{"id":5547,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/5546\/revisions\/5547"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=5546"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=5546"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=5546"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}