{"id":6039,"date":"2021-02-08T06:00:24","date_gmt":"2021-02-08T04:00:24","guid":{"rendered":"http:\/\/www.glc.us.es\/~jalonso\/exercitium\/?p=6039"},"modified":"2021-02-15T09:56:54","modified_gmt":"2021-02-15T07:56:54","slug":"mayor-numero-borrando-k-digitos","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/mayor-numero-borrando-k-digitos\/","title":{"rendered":"Mayor n\u00famero borrando k d\u00edgitos"},"content":{"rendered":"<p>Definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   mayorBorrando :: Int -> Integer -> Integer\n<\/pre>\n<p>tal que (mayorBorrando k n) es el mayor n\u00famero obtenido borrando k d\u00edgitos de n (se supone que n tiene m\u00e1s de k d\u00edgitos). Por ejemplo,<\/p>\n<pre lang=\"text\">\n   mayorBorrando 1 6782334  ==  782334\n   mayorBorrando 3 6782334  ==  8334\n   mayorBorrando 3 10020    ==  20\n   mayorBorrando 1000000 (4256 + 10^1000004) == 14256\n<\/pre>\n<h4>Soluciones<\/h4>\n<pre lang=\"haskell\">\nimport Data.List (subsequences)\n\n-- 1\u00aa definici\u00f3n\n-- =============\n\nmayorBorrando :: Int -> Integer -> Integer\nmayorBorrando k n = read (mayorBorrandoLista1 k (show n))\n\n-- (mayorBorrandoLista1 k xs) es la mayor lista obtenida borrando k elementos de\n-- xs (se supone que xs tiene m\u00e1s de k elementos). Por ejemplo,\n--    mayorBorrandoLista1 1 \"6782334\"  ==  \"782334\"\n--    mayorBorrandoLista1 3 \"6782334\"  ==  \"8334\"\nmayorBorrandoLista1 :: Ord a => Int -> [a] -> [a]\nmayorBorrandoLista1 k xs = maximum (borra1 k xs)\n\n-- (borra1 k xs) es la lista de las listas obtenidas borrando k elementos\n-- de xs. Por ejemplo,\n--    borra1 1 \"abcd\"  ==  [\"abc\",\"abd\",\"acd\",\"bcd\"]\n--    borra1 2 \"abcd\"  ==  [\"ab\",\"ac\",\"bc\",\"ad\",\"bd\",\"cd\"]\n--    borra1 3 \"abcd\"  ==  [\"a\",\"b\",\"c\",\"d\"]\nborra1 n xs = [ys | ys <- subsequences xs, length ys == k]\n  where k = length xs - n\n\n-- 2\u00aa definici\u00f3n\n-- =============\n\nmayorBorrando2 :: Int -> Integer -> Integer\nmayorBorrando2 k n = read (mayorBorrandoLista2 k (show n))\n\n-- (mayorBorrandoLista2 k xs) es la mayor lista obtenida borrando k elementos de\n-- xs (se supone que xs tiene m\u00e1s de k elementos). Por ejemplo,\n--    mayorBorrandoLista2 1 \"6782334\"  ==  \"782334\"\n--    mayorBorrandoLista2 3 \"6782334\"  ==  \"8334\"\nmayorBorrandoLista2 :: Ord a => Int -> [a] -> [a]\nmayorBorrandoLista2 k xs = maximum (borra2 k xs)\n\n-- (borra2 k xs) es la lista de las listas obtenidas borrando k elementos\n-- de xs. Por ejemplo,\n--    borra2 1 \"abcd\"  ==  [\"abc\",\"abd\",\"acd\",\"bcd\"]\n--    borra2 2 \"abcd\"  ==  [\"ab\",\"ac\",\"ad\",\"bc\",\"bd\",\"cd\"]\n--    borra2 3 \"abcd\"  ==  [\"a\",\"b\",\"c\",\"d\"]\nborra2 :: Eq a => Int -> [a] -> [[a]]\nborra2 0 xs     = [xs]\nborra2 n []     = []\nborra2 n (x:xs) = [x:ys | ys <- borra2 n xs] ++ borra2 (n-1) xs\n\n-- 3\u00aa definici\u00f3n\n-- =============\n\nmayorBorrando3 :: Int -> Integer -> Integer\nmayorBorrando3 k n = read (mayorBorrandoLista3 k (show n))\n\n-- (mayorBorrandoLista3 k xs) es la mayor lista obtenida borrando k elementos de\n-- xs (se supone que xs tiene m\u00e1s de k elementos). Por ejemplo,\n--    mayorBorrandoLista3 1 \"6782334\"  ==  \"782334\"\n--    mayorBorrandoLista3 3 \"6782334\"  ==  \"8334\"\nmayorBorrandoLista3 :: Ord a => Int -> [a] -> [a]\nmayorBorrandoLista3 k xs = maximum (itera k borraUnoListas [xs])\n\n-- (borraUnoListas xss) es la lista obtenida borrando un elemento (de\n-- todas las formas posibles de la lista de listas no vac\u00edas xss. Por\n-- ejemplo,\n--    borraUnoListas [\"abc\",\"def\"]  ==  [\"bc\",\"ac\",\"ab\",\"ef\",\"df\",\"de\"]\nborraUnoListas :: [[a]] -> [[a]]\nborraUnoListas = concatMap borraUno\n\n-- (borraUno xs) es la lista de listas obtenidas borrando un elemento de la\n-- lista no vac\u00eda xs de todas las formas posibles. Por ejemplo,\n--    borraUno \"abcde\"  ==  [\"bcde\",\"acde\",\"abde\",\"abce\",\"abcd\"]\nborraUno :: [a] -> [[a]]\nborraUno [x] = [[]]\nborraUno (x:xs) = xs : map (x:) (borraUno xs)\n\n-- (itera k f x) es el resultado de aplicar k veces la funci\u00f3n f al\n-- elemento x. Por ejmplo,\n--    itera 3 (*2) 1   ==  8\n--    itera 4 (+2) 10  ==  18\nitera :: Eq a => Int -> (a -> a) -> a -> a\nitera 0 _ x = x\nitera n f x = itera (n-1) f (f x)\n\n-- 4\u00aa definici\u00f3n\n-- =============\n\nmayorBorrando4 :: Int -> Integer -> Integer\nmayorBorrando4 k n = read (mayorBorrandoLista4 k (show n))\n\n-- (mayorBorrandoLista4 k xs) es la mayor lista obtenida borrando k elementos de\n-- xs (se supone que xs tiene m\u00e1s de k elementos). Por ejemplo,\n--    mayorBorrandoLista4 1 \"6782334\"  ==  \"782334\"\n--    mayorBorrandoLista4 3 \"6782334\"  ==  \"8334\"\nmayorBorrandoLista4 :: Ord a => Int -> [a] -> [a]\nmayorBorrandoLista4 k = itera k mayorBorraUno\n\n-- (mayorBorraUno xs) es la mayor lista obtenida eliminando un elemento de\n-- xs. Por ejemplo,\n--    mayorBorraUno \"6782334\"  ==  \"782334\"\n--    mayorBorraUno \"782334\"   ==  \"82334\"\n--    mayorBorraUno \"82334\"    ==  \"8334\"\nmayorBorraUno :: Ord a => [a] -> [a]\nmayorBorraUno = maximum . borraUno\n\n-- 5\u00aa definici\u00f3n\n-- =============\n\nmayorBorrando5 :: Int -> Integer -> Integer\nmayorBorrando5 k n = read (mayorBorrandoLista5 k (show n))\n\n-- (mayorBorrandoLista5 k xs) es la mayor lista obtenida borrando k elementos de\n-- xs (se supone que xs tiene m\u00e1s de k elementos). Por ejemplo,\n--    mayorBorrandoLista5 1 \"6782334\"  ==  \"782334\"\n--    mayorBorrandoLista5 3 \"6782334\"  ==  \"8334\"\nmayorBorrandoLista5 :: Ord a => Int -> [a] -> [a]\nmayorBorrandoLista5 k = itera k mayorBorraUno2\n\n-- (mayorBorraUno2 xs) es la mayor lista obtenida eliminando un elemento de\n-- xs. Por ejemplo,\n--    mayorBorraUno2 \"6782334\"  ==  \"782334\"\n--    mayorBorraUno2 \"782334\"   ==  \"82334\"\n--    mayorBorraUno2 \"82334\"    ==  \"8334\"\nmayorBorraUno2 :: Ord a => [a] -> [a]\nmayorBorraUno2 [x]      = []\nmayorBorraUno2 (x:y:xs) | x < y     = y:xs\n                        | otherwise = x : mayorBorraUno2 (y:xs)\n\n-- 6\u00aa definici\u00f3n\n-- =============\n\nmayorBorrando6 :: Int -> Integer -> Integer\nmayorBorrando6 k n = read (mayorBorrandoLista6 k (show n))\n\n-- (mayorBorrandoLista6 k xs) es la mayor lista obtenida borrando k elementos de\n-- xs (se supone que xs tiene m\u00e1s de k elementos). Por ejemplo,\n--    mayorBorrandoLista6 1 \"6782334\"  ==  \"782334\"\n--    mayorBorrandoLista6 3 \"6782334\"  ==  \"8334\"\nmayorBorrandoLista6 :: Ord a => Int -> [a] -> [a]\nmayorBorrandoLista6 k xs = aux k [] xs\n\naux 0 ys     xs     = reverse ys ++ xs\naux k ys     []     = reverse (drop k ys)\naux k []     (x:xs) = aux k [x] xs\naux k (y:ys) (x:xs) | y >= x    = aux k     (x:y:ys) xs\n                    | otherwise = aux (k-1) ys       (x:xs)\n\n-- Comparaci\u00f3n de eficiencia\n-- =========================\n\n-- La comparaci\u00f3n es\n--    \u03bb> mayorBorrando 6 (product [1..18])\n--    7705728000\n--    (0.06 secs, 15,165,496 bytes)\n--    \u03bb> mayorBorrando2 6 (product [1..18])\n--    7705728000\n--    (0.04 secs, 19,662,816 bytes)\n--    \u03bb> mayorBorrando3 6 (product [1..18])\n--    7705728000\n--    (6.93 secs, 5,143,807,064 bytes)\n--    \u03bb> mayorBorrando4 6 (product [1..18])\n--    7705728000\n--    (0.01 secs, 183,728 bytes)\n--    \u03bb> mayorBorrando5 6 (product [1..18])\n--    7705728000\n--    (0.01 secs, 118,984 bytes)\n--    \u03bb> mayorBorrando6 6 (product [1..18])\n--    7705728000\n--\n--    \u03bb> mayorBorrando 17 (product [1..25])\n--    998400000\n--    (19.09 secs, 14,516,359,464 bytes)\n--    \u03bb> mayorBorrando2 17 (product [1..25])\n--    998400000\n--    (47.39 secs, 30,066,413,608 bytes)\n--    \u03bb> mayorBorrando4 17 (product [1..25])\n--    998400000\n--    (0.01 secs, 458,320 bytes)\n--    \u03bb> mayorBorrando5 17 (product [1..25])\n--    998400000\n--    (0.01 secs, 134,424 bytes)\n--    \u03bb> mayorBorrando6 17 (product [1..25])\n--    984000000\n--    (0.01 secs, 124,600 bytes)\n--\n--    \u03bb> mayorBorrando4 600 (product [1..300])\n--    999999999999999\n--    (3.29 secs, 4,421,841,944 bytes)\n--    \u03bb> mayorBorrando5 600 (product [1..300])\n--    999999999999999\n--    (0.03 secs, 6,690,440 bytes)\n--    \u03bb> mayorBorrando6 600 (product [1..300])\n--    960000000000000\n--    (0.01 secs, 593,864 bytes)\n--\n--    \u03bb> mayorBorrando5 10000 (4256 + 10^10004)\n--    14256\n--    (16.04 secs, 18,221,784,872 bytes)\n--    \u03bb> mayorBorrando6 10000 (4256 + 10^10004)\n--    14256\n--    (0.02 secs, 6,669,592 bytes)\n--\n--    \u03bb> mayorBorrando6 1000000 (4256 + 10^1000004)\n--    14256\n--    (1.04 secs, 655,561,656 bytes)\n<\/pre>\n<h4>Nuevas soluciones<\/h4>\n<ul>\n<li>En los comentarios se pueden escribir nuevas soluciones.\n<li>El c\u00f3digo se debe escribir entre una l\u00ednea con &#60;pre lang=&quot;haskell&quot;&#62; y otra con &#60;\/pre&#62;\n<\/ul>\n","protected":false},"excerpt":{"rendered":"<p>Definir la funci\u00f3n mayorBorrando :: Int -> Integer -> Integer tal que (mayorBorrando k n) es el mayor n\u00famero obtenido borrando k d\u00edgitos de n (se supone que n tiene m\u00e1s de k d\u00edgitos). Por ejemplo, mayorBorrando 1 6782334 == 782334 mayorBorrando 3 6782334 == 8334 mayorBorrando 3 10020 == 20 mayorBorrando 1000000 (4256 +&#8230;<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","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":[7],"tags":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/wp-json\/wp\/v2\/posts\/6039"}],"collection":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/wp-json\/wp\/v2\/comments?post=6039"}],"version-history":[{"count":4,"href":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/wp-json\/wp\/v2\/posts\/6039\/revisions"}],"predecessor-version":[{"id":6087,"href":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/wp-json\/wp\/v2\/posts\/6039\/revisions\/6087"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/wp-json\/wp\/v2\/media?parent=6039"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/wp-json\/wp\/v2\/categories?post=6039"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/exercitium\/wp-json\/wp\/v2\/tags?post=6039"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}