{"id":2483,"date":"2013-01-17T17:30:48","date_gmt":"2013-01-17T17:30:48","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=2483"},"modified":"2013-03-08T05:47:35","modified_gmt":"2013-03-08T05:47:35","slug":"i1m2012-ejercicios-sobre-el-2013-y-funciones-de-orden-superior","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2012-ejercicios-sobre-el-2013-y-funciones-de-orden-superior\/","title":{"rendered":"I1M2012: Ejercicios sobre el 2013 y funciones de orden superior"},"content":{"rendered":"<p>En la clase de hoy de <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-12\">Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas<\/a> hemos comentado las soluciones de los 3 primeros  ejercicios de la <a href=\"https:\/\/www.glc.us.es\/~jalonso\/ejerciciosI1M2012G2\/images\/5\/59\/Rel_13.hs\">13\u00aa relaci\u00f3n<\/a> (de propiedades del 2013) y los 3 primeros  ejercicios de la <a href=\"https:\/\/www.glc.us.es\/~jalonso\/ejerciciosI1M2012G2\/images\/e\/e4\/Rel_14.hs\">14\u00aa relaci\u00f3n<\/a> (de funciones de orden superior). <\/p>\n<p>Los ejercicios, y sus soluciones, se muestran a continuaci\u00f3n: Los de la 13\u00aa relaci\u00f3n son<br \/>\n<!--more--><\/p>\n<pre lang=\"haskell\">\r\n-- ---------------------------------------------------------------------\r\n-- Importaci\u00f3n de librer\u00edas auxiliares                                --\r\n-- ---------------------------------------------------------------------\r\n\r\nimport Data.List\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1. [Potencias de 2013] En los apartados de este ejercicio\r\n-- se resuelven problemas sobre potencias del 2013 como los siguientes: \r\n-- (a) \u00bfCu\u00e1l es el menor n, tal que n aparece en 2013^n en la posici\u00f3n\r\n--     n? \r\n-- (b) \u00bfCu\u00e1l es el menor n (mayor que 1), tal que dentro 2013^n aparece\r\n--     el 2013? \u00bfEn qu\u00e9 posici\u00f3n aparece? \r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.1. Definir la funci\u00f3n \r\n--    posiciones :: Eq a => [a] -> [a] -> [Int]\r\n-- tal que (posiciones xs ys) es la lista de las posiciones que ocupa xs\r\n-- dentro de ys. Por ejemplo,\r\n--    posiciones \"ac\" \"bacdacaec\"  ==  [2,5]\r\n-- ---------------------------------------------------------------------\r\n\r\nposiciones :: Eq a => [a] -> [a] -> [Int]\r\nposiciones xs ys = aux ys 1\r\n    where aux [] n = []\r\n          aux (y:ys) n | isPrefixOf xs (y:ys) = n : aux ys (n+1)\r\n                       | otherwise            = aux ys (n+1)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.2. Definir la funci\u00f3n\r\n--    posicionesEnPotencia :: Integer -> Integer -> [Int]\r\n-- tal que (posicionesEnPotencia n m) es la lista de las posiciones del\r\n-- n\u00famero n en 2013^m. Por ejemplo,\r\n--    posicionesEnPotencia 1 1    ==  [3]\r\n--    posicionesEnPotencia 2 2    ==  [4]\r\n--    posicionesEnPotencia 3 3    ==  []\r\n--    posicionesEnPotencia 4 4    ==  [3,11]\r\n--    posicionesEnPotencia 5 5    ==  [4,11]\r\n--    posicionesEnPotencia 6 6    ==  [1,2,5]\r\n--    posicionesEnPotencia 58 58  ==  [26,32,55,59,79]\r\n-- ---------------------------------------------------------------------\r\n\r\nposicionesEnPotencia :: Integer -> Integer -> [Int]\r\nposicionesEnPotencia n m = posiciones (show n) (show (2013^m)) \r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.3. Definir el ejercicio\r\n--    enPosicion :: Eq a => [a] -> [a] -> Int -> Bool\r\n-- tal que (enPosicion xs ys n) se verifica si xs est\u00e1 en ys en la\r\n-- posici\u00f3n n. Por ejemplo, \r\n--    enPosicion \"ab\" \"cabdab\" 2  ==  True\r\n--    enPosicion \"ab\" \"cabdab\" 5  ==  True\r\n--    enPosicion \"ab\" \"cabdab\" 4  ==  False\r\n-- ---------------------------------------------------------------------\r\n\r\nenPosicion :: Eq a => [a] -> [a] -> Int -> Bool\r\nenPosicion xs ys n = isPrefixOf xs (drop (n-1) ys)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.4. Definir el ejercicio\r\n--    enPosicionPotencia :: Integer -> Integer -> Int -> Bool\r\n-- tal que (enPosicionPotencia x y n) se verifica si x est\u00e1 en 2013^y en\r\n-- la posici\u00f3n n. Por ejemplo, \r\n--    enPosicionPotencia 4 4 3  ==  True\r\n--    enPosicionPotencia 4 4 5  ==  False\r\n-- ---------------------------------------------------------------------\r\n\r\nenPosicionPotencia :: Integer -> Integer -> Int -> Bool\r\nenPosicionPotencia x y n = \r\n    enPosicion (show x) (show (2013^y)) n\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.5. Calcular el menor n, tal que n aparece en la posici\u00f3n\r\n-- n de 2013^n.\r\n-- ---------------------------------------------------------------------\r\n\r\nmenorFijo :: Integer\r\nmenorFijo = \r\n    head [n | n <- [1..], enPosicionPotencia n n (fromIntegral n)]\r\n\r\n-- El c\u00e1lculo es\r\n--    ghci> menorFijo\r\n--    83\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1.6. Calcular el menor n (mayor que 1), tal que dentro\r\n-- 2013^n aparezca el 2013. \u00bfEn qu\u00e9 posici\u00f3n aparece el 2013?\r\n-- ---------------------------------------------------------------------\r\n\r\nmenorPotenciaConteniendo2013 :: Integer\r\nmenorPotenciaConteniendo2013 =\r\n    head [n | n <- [2..], not (null (posicionesEnPotencia 2013 n))]\r\n\r\n-- El c\u00e1lculo es\r\n--    ghci> menorPotenciaConteniendo2013\r\n--    98\r\n--    ghci> posicionesEnPotencia 2013 98\r\n--    [23,170]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2. [2013 en factoriales] Con los apartados de este\r\n-- ejercicio se resuelve el siguiente problema: \r\n--    \u00bfCu\u00e1l es el primer factorial que tiene a \"2013\" dentro?\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2.1. Definir la funci\u00f3n\r\n--    fact :: Int -> Int \r\n-- tal que (fact n) es el factorial de n. Por ejemplo,\r\n--    fact 5  ==  120\r\n--    fact 18  ==  6402373705728000\r\n-- ---------------------------------------------------------------------\r\n\r\nfact :: Integer -> Integer \r\nfact n = product [1..n]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2.2. Definir la funci\u00f3n\r\n--    enFactorial :: Int -> Bool\r\n-- tal que (enFactorial n) es el menor x tal que x ocurre dentro del\r\n-- factorial de x. Por ejemplo,\r\n--    enFactorial 20  ==  5\r\n--    enFactorial 23  ==  18\r\n-- ---------------------------------------------------------------------\r\n\r\nenFactorial :: Integer -> Integer \r\nenFactorial n = \r\n    head [x | x <- [0..], isInfixOf (show n) (show (fact x))]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2.3. Calcular el menor n tal que 2013 ocurre dentro del\r\n-- factorial de n. \u00bfQu\u00e9 posici\u00f3n ocupa?\r\n-- ---------------------------------------------------------------------\r\n\r\n-- El c\u00e1lculo es\r\n--    ghci> enFactorial 2013\r\n--    68\r\n--    ghci> fact 68\r\n--    24800355424368305996009904185691715810473992013553676723717\r\n--    10738018221445712183296000000000000000\r\n--    ghci> posiciones (show 2013) (show (fact 68))\r\n--    [44]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 3. [2013 en potencias de 2] Con los apartados de este\r\n-- ejercicio se resuelve el siguiente problema\r\n--    \u00bfCu\u00e1l es la primer potencia de 2 que tiene \"2013\" dentro? \u00bfy las\r\n--    siguientes? \r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 3.1. Definir la funci\u00f3n\r\n--    enPotenciaDeDos :: Integer -> [Integer]\r\n-- tal que (enPotenciaDeDos n) es la lista de los n\u00fameros x tales que n\r\n-- aparece dentro de 2^n. Por ejemplo,\r\n--    head (enPotenciaDeDos 21)  ==  18\r\n--    2^18                       ==  262144\r\n-- ---------------------------------------------------------------------\r\n\r\nenPotenciaDeDos :: Integer -> [Integer]\r\nenPotenciaDeDos n = \r\n    [x | x <- [0..], isInfixOf (show n) (show (2^x))]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 3.2. Calcular los 10 primeros n\u00fameros x tales que 2013\r\n-- aparece dentro de 2^x.\r\n-- ---------------------------------------------------------------------\r\n\r\n-- El c\u00e1lculo es\r\n--    ghci> take 10 (enPotenciaDeDos 2013)\r\n--    [163,310,613,619,643,644,702,736,784,865]\r\n\r\n<\/pre>\n<p>y los de la 14\u00aa relaci\u00f3n son<\/p>\n<pre lang=\"haskell\">\r\n-- ---------------------------------------------------------------------\r\n-- Importaci\u00f3n de librer\u00edas auxiliares                                --\r\n-- ---------------------------------------------------------------------\r\n\r\nimport Test.QuickCheck\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1. Redefinir por recursi\u00f3n la funci\u00f3n\r\n--    takeWhile :: (a -> Bool) -> [a] -> [a]\r\n-- tal que (takeWhile p xs) es la lista de los elemento de xs hasta el\r\n-- primero que no cumple la propiedad p. Por ejemplo,\r\n--    takeWhile' (<7) [2,3,9,4,5]  ==  [2,3]\r\n-- ---------------------------------------------------------------------\r\n\r\ntakeWhile' :: (a -> Bool) -> [a] -> [a]\r\ntakeWhile' _ [] = []\r\ntakeWhile' p (x:xs) \r\n    | p x       = x : takeWhile' p xs\r\n    | otherwise = []\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2. Redefinir por recursi\u00f3n la funci\u00f3n\r\n--    dropWhile :: (a -> Bool) -> [a] -> [a]\r\n-- tal que (dropWhile p xs) es la lista de eliminando los elemento de xs\r\n-- hasta el primero que cumple la propiedad p. Por ejemplo,\r\n--    dropWhile' (<7) [2,3,9,4,5]  ==  [9,4,5]\r\n-- ---------------------------------------------------------------------\r\n\r\ndropWhile' :: (a -> Bool) -> [a] -> [a]\r\ndropWhile' _ [] = []\r\ndropWhile' p (x:xs)\r\n    | p x       = dropWhile' p xs\r\n    | otherwise = x:xs\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 3. Redefinir, usando foldr, la funci\u00f3n concat. Por ejemplo, \r\n--    concat' [[1,3],[2,4,6],[1,9]]  ==  [1,3,2,4,6,1,9]\r\n-- ---------------------------------------------------------------------\r\n\r\n-- La definici\u00f3n por recursi\u00f3n es \r\nconcatR :: [[a]] -> [a]\r\nconcatR [] = []\r\nconcatR (xs:xss) = xs ++ concatR xss\r\n\r\n-- La definici\u00f3n por plegado es\r\nconcat' :: [[a]] -> [a]\r\nconcat' = foldr (++) []\r\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 las soluciones de los 3 primeros ejercicios de la 13\u00aa relaci\u00f3n (de propiedades del 2013) y los 3 primeros ejercicios de la 14\u00aa relaci\u00f3n (de funciones de orden superior). Los ejercicios, y sus soluciones, se muestran a continuaci\u00f3n: Los de&#8230;<\/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":[1],"tags":[298],"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\/2483"}],"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=2483"}],"version-history":[{"count":7,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/2483\/revisions"}],"predecessor-version":[{"id":2702,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/2483\/revisions\/2702"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=2483"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=2483"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=2483"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}