{"id":1157,"date":"2011-01-17T08:07:06","date_gmt":"2011-01-17T08:07:06","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=1157"},"modified":"2023-07-30T08:47:15","modified_gmt":"2023-07-30T06:47:15","slug":"i1m2010-ejercicios-de-haskell-relacion-14","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2010-ejercicios-de-haskell-relacion-14\/","title":{"rendered":"I1M2010: Ejercicios de Haskell (relaci\u00f3n 14)"},"content":{"rendered":"<p>En la clase de hoy de <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-10\">Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas<\/a> hemos comentado la resoluci\u00f3n de los 12 primeros ejercicios de la <a href=\"https:\/\/www.glc.us.es\/~jalonso\/ejerciciosI1M2010\/index.php5\/Relaci%C3%B3n_14\">14\u00aa relaci\u00f3n<\/a>.<\/p>\n<p>Los ejercicios y su soluci\u00f3n se muestran a continuaci\u00f3n<br \/>\n<!--more--><\/p>\n<pre lang=\"haskell\">\n-- Cada comienzo de a\u00f1o se suelen buscar propiedades num\u00e9ricas del\n-- n\u00famero del a\u00f1o. En el 2011 se han buscado propiedades que relacionan\n-- el 2011 y los n\u00fameros primos. En este ejercicio vamos a realizar la\n-- b\u00fasqueda de dichas propiedades con Haskell.\n\nimport Data.List (sort)\n\n-- La criba de Erast\u00f3tenes es un m\u00e9todo para calcular n\u00fameros primos. Se\n-- comienza escribiendo todos los n\u00fameros desde 2 hasta (supongamos)\n-- 100. El primer n\u00famero (el 2) es primo. Ahora eliminamos todos los\n-- m\u00faltiplos de 2. El primero de los n\u00fameros restantes (el 3) tambi\u00e9n es\n-- primo. Ahora eliminamos todos los m\u00faltiplos de 3. El primero de los\n-- n\u00fameros restantes (el 5) tambi\u00e9n es primo ... y as\u00ed\n-- sucesivamente. Cuando no quedan n\u00fameros, se han encontrado todos los\n-- n\u00fameros primos en el rango fijado. \n\n-- ---------------------------------------------------------------------\n-- Ejercicio 1. Definir la funci\u00f3n\n--    elimina :: Int -> [Int] -> [Int]\n-- tal que (elimina n xs) es la lista obtenida eliminando en la lista xs\n-- los m\u00faltiplos de n. Por ejemplo,  \n--    elimina 3 [2,3,8,9,5,6,7]  ==  [2,8,5,7]\n-- ---------------------------------------------------------------------\n\n-- Por comprensi\u00f3n:\nelimina :: Int -> [Int] -> [Int]\nelimina n xs = [ x | x <- xs, x `mod` n \/= 0 ]\n\n-- Por recursi\u00f3n:\neliminaR :: Int -> [Int] -> [Int]\neliminaR n [] = []\neliminaR n (x:xs) | mod x n == 0 = eliminaR n xs\n                  | otherwise    = x : eliminaR n xs\n\n-- Por plegado:\neliminaP :: Int -> [Int] -> [Int]\neliminaP n = foldr f [] \n             where f x y | mod x n == 0 = y\n                         | otherwise    = x:y\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 2. Definir la funci\u00f3n\n--    criba :: [Int] -> [Int]\n-- tal que (criba xs) es la lista obtenida cribando la lista xs con el\n-- m\u00e9todo descrito anteriormente. Por ejemplo, \n--    criba [2..20]          ==  [2,3,5,7,11,13,17,19]\n--    take 10 (criba [2..])  ==  [2,3,5,7,11,13,17,19,23,29]\n-- ---------------------------------------------------------------------\n\ncriba :: [Int] -> [Int]\ncriba []     = []\ncriba (n:ns) = n : criba (elimina n ns)\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 3. Definir la funci\u00f3n\n--    primos :: [Int]\n-- cuyo valor es la lista de los n\u00fameros primos. Por ejemplo,\n--    take 10 primos  ==  [2,3,5,7,11,13,17,19,23,29]\n-- ---------------------------------------------------------------------\n\nprimos :: [Int]\nprimos = criba [2..]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 4. Definir la funci\u00f3n\n--    esPrimo :: Int -> Bool\n-- tal que (esPrimo n) se verifica si n es primo. Por ejemplo,\n--    esPrimo 7  ==  True\n--    esPrimo 9  ==  False\n-- ---------------------------------------------------------------------\n\nesPrimo :: Int -> Bool\nesPrimo n = head (dropWhile (<n) primos) == n\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 5. Comprobar que 2011 es primo.\n-- ---------------------------------------------------------------------\n\n-- La comprobaci\u00f3n es\n--     ghci> esPrimo 2011\n--     True\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 6. Definir la funci\u00f3n \n--    prefijosConSuma :: [Int] -> Int -> [[Int]]\n-- tal que (prefijosConSuma xs n) es la lista de los prefijos de xs cuya\n-- suma es n. Por ejemplo, \n--    prefijosConSuma [1..10] 3  == [[1,2]]\n--    prefijosConSuma [1..10] 4  == []\n-- ---------------------------------------------------------------------\n\nprefijosConSuma :: [Int] -> Int -> [[Int]]\nprefijosConSuma [] 0 = [[]]\nprefijosConSuma [] n = []\nprefijosConSuma (x:xs) n \n    | x < n  = [x:ys | ys <- prefijosConSuma xs (n-x)]\n    | x == n = [[x]]\n    | x > n  = []\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 7. Definir la funci\u00f3n\n--    consecutivosConSuma :: [Int] -> Int -> [[Int]]\n-- (consecutivosConSuma xs n) es la lista de los elementos consecutivos\n-- de xs cuya suma es n. Por ejemplo, \n--    consecutivosConSuma [1..10] 9  == [[2,3,4],[4,5],[9]]\n-- ---------------------------------------------------------------------\n\nconsecutivosConSuma :: [Int] -> Int -> [[Int]]\nconsecutivosConSuma [] 0 = [[]]\nconsecutivosConSuma [] n = []\nconsecutivosConSuma (x:xs) n =\n    (prefijosConSuma (x:xs) n) ++ (consecutivosConSuma xs n)\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 8. Definir la funci\u00f3n\n--    primosConsecutivosConSuma :: Int -> [[Int]]\n-- tal que (primosConsecutivosConSuma n) es la lista de los n\u00fameros\n-- primos consecutivos cuya suma es n. Por ejemplo,\n--    ghci> primosConsecutivosConSuma 41\n--    [[2,3,5,7,11,13],[11,13,17],[41]]\n-- ---------------------------------------------------------------------\n\nprimosConsecutivosConSuma :: Int -> [[Int]]\nprimosConsecutivosConSuma n = \n    consecutivosConSuma (takeWhile (<=n) primos) n\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 9. Calcular las descomposiciones de 2011 como sumas de\n-- primos consecutivos. \n-- ---------------------------------------------------------------------\n\n-- El c\u00e1lculo es\n--    ghci> primosConsecutivosConSuma 2011\n--    [[157,163,167,173,179,181,191,193,197,199,211],[661,673,677],[2011]]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 10. Definir la funci\u00f3n\n--    propiedad1 :: Int -> Bool\n-- tal que (propiedad1 n) se verifica si n s\u00f3lo se puede expresar como\n-- sumas de 1, 3 y 11 primos consecutivos. Por ejemplo,\n--    propiedad1 2011  ==  True\n--    propiedad1 2010  ==  False\n-- ---------------------------------------------------------------------\n\npropiedad1 :: Int -> Bool\npropiedad1 n =\n    sort (map length (primosConsecutivosConSuma n)) == [1,3,11]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 11. Calcular los a\u00f1os hasta el 3000 que cumplen la\n-- propiedad1. \n-- ---------------------------------------------------------------------\n\n-- El c\u00e1lculo es\n--    ghci> [n | n <- [1..3000], propiedad1 n]\n--    [883,2011]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 12. Definir la funci\u00f3n\n--    sumaCifras :: Int -> Int\n-- tal que (sumaCifras x) es la suma de las cifras del n\u00famero x. Por\n-- ejemplo, \n--    sumaCifras 254  ==  11\n-- ---------------------------------------------------------------------\n\nsumaCifras :: Int -> Int\nsumaCifras x = sum [read [y] | y <- show x]\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 la resoluci\u00f3n de los 12 primeros ejercicios de la 14\u00aa relaci\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":"closed","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":[133],"tags":[287],"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\/1157"}],"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=1157"}],"version-history":[{"count":3,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/1157\/revisions"}],"predecessor-version":[{"id":7984,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/1157\/revisions\/7984"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=1157"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=1157"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=1157"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}