{"id":3950,"date":"2013-12-25T08:04:06","date_gmt":"2013-12-25T07:04:06","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=3950"},"modified":"2016-01-09T18:39:11","modified_gmt":"2016-01-09T17:39:11","slug":"el-problema-de-josefo-en-haskell","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/el-problema-de-josefo-en-haskell\/","title":{"rendered":"El problema de Josefo en Haskell"},"content":{"rendered":"<p>El <a href=\"http:\/\/en.wikipedia.org\/wiki\/Josephus_problem\">problema de Josefo<\/a> hace referencia a Flavio Josefo, un historiador jud\u00edo que vivi\u00f3 en el siglo I. Seg\u00fan lo que cuenta Josefo, \u00e9l y cuarenta soldados camaradas fueron capturados por los romanos. Antes que rendirse, decidieron acabar ellos mismos con sus vidas. Para hacerlo, se dispusieron en un c\u00edrculo y acordaron que ir\u00edan contando de tres en tres, de forma que cada tercer soldado ser\u00eda ejecutado por la persona de su izquierda. El \u00faltimo hombre que quedara con vida tendr\u00eda que suicidarse. Seg\u00fan cuenta la leyenda, Josefo calcul\u00f3 r\u00e1pidamente cu\u00e1l ser\u00eda la posici\u00f3n del \u00faltimo hombre en morir para colocarse all\u00ed, y una vez hubieron muerto sus compatriotas, se entreg\u00f3 a los romanos.<\/p>\n<p>El enunciado del problema de Josefo de orden (n,m) es el siguiente: Se tienen n personas entorno a un c\u00edrculo, ordenadas y numeradas  desde la primera a la n-\u00e9sima. Empezando por la persona n\u00famero 1, se saltan m-1 personas y se mata a la m-\u00e9sima. A continuaci\u00f3n se saltan otras m-1 personas y se ejecuta a la siguiente. El proceso contin\u00faa hasta que s\u00f3lo quede una. El objetivo es, dados n y m, encontrar el lugar inicial en el c\u00edrculo para sobrevivir.<\/p>\n<p>A continuaci\u00f3n muestro una relaci\u00f3n de ejercicios (elaborada para la asignatura de <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m\">Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas<\/a> y para la siguiente versi\u00f3n del libro <a href=\"http:\/\/www.cs.us.es\/~jalonso\/publicaciones\/Piensa_en_Haskell.pdf\">Piensa en Haskell<\/a>) en la que se presentan distintas soluciones y se compara su eficiencia.<\/p>\n<p><!--more--><\/p>\n<pre lang=\"haskell\">\n-- ---------------------------------------------------------------------\n-- \u00a7 1\u00aa soluci\u00f3n (con la sucesi\u00f3n de estados)                         --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 1. Consideremos el problema de Josefo con n=4 y m=2. La\n-- sucesi\u00f3n de estados es, donde con * se indica el \u00faltimo eliminado,\n--    1 2    |  1 *    |  1      |  1         \n--    4 3    |  4 3    |  * 3    |     *\n-- La sucesi\u00f3n anterior se puede representar por\n--    [[1,2,3,4],[3,4,1],[1,3],[1]]\n-- Para n=5 y m=2, la sucesi\u00f3n de estados es\n--    1 2 3  |  1 * 3  |  1   3  |  *   3  |      3     \n--     5 4   |   5 4   |   5 *   |   5     |   *        \n-- que se puede representar por\n--    [[1,2,3,4,5],[3,4,5,1],[5,1,3],[3,5],[3]]\n-- Observar que en cada lista el primer elemento es el que est\u00e1 a\n-- continuaci\u00f3n de la * en el sentido horario.\n--  \n-- Definir la funci\u00f3n\n--    siguiente :: [Int] -> Int -> [Int]\n-- tal que (siguiente xs m) es la lista obtenida a\u00f1adiendo k-1 primeros\n-- elementos de xs al final de la lista obtenida borrando los k primeros\n-- elementos de xs, donde k es el resto de dividir m entre la longitud\n-- de xs. Por ejemplo,\n--    siguiente [1..4]  2  ==  [3,4,1]\n--    siguiente [3,4,1] 2  ==  [1,3]\n--    siguiente [1,3]   2  ==  [3]\n--    siguiente [3]     2  ==  [3]\n--    siguiente [1..4]  7  ==  [4,1,2]\n-- ---------------------------------------------------------------------\n\nsiguiente :: [Int] -> Int -> [Int]\nsiguiente [x] _ = [x]\nsiguiente xs m  = zs ++ ys\n    where (ys,z:zs) = splitAt ((m-1) `rem` length xs) xs\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 2. Definir la funci\u00f3n\n--    sucesionJ :: Int -> Int -> [[Int]]\n-- tal que (sucesionJ n m) es la lista de los sucesivos estados del\n-- problema de Josefo con n posiciones y saltando m-1 cada vez. Por\n-- ejemplo, \n--    ghci> sucesionJ 4 2\n--    [[1,2,3,4],[3,4,1],[1,3],[1]]\n--    ghci> sucesionJ 5 2\n--    [[1,2,3,4,5],[3,4,5,1],[5,1,3],[3,5],[3]]\n-- ---------------------------------------------------------------------\n\nsucesionJ :: Int -> Int -> [[Int]]\nsucesionJ n m = aux [1..n] m\n    where aux [x] _ = [[x]]\n          aux xs  m = xs : aux (siguiente xs m) m\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 3. Definir la funci\u00f3n\n--    josefo1 :: Int -> Int -> Int\n-- tal que (josefo1 n m) es la posici\u00f3n del superviviente para el\n-- problema de Josefo con n elementos y saltando m-1 cada vez. Por\n-- ejemplo,\n--    ghci> josefo1 4 2\n--    1\n--    ghci> josefo1 5 2\n--    3\n--    ghci> [josefo1 n 2 | n <- [1..16]]\n--    [1,1,3,1,3,5,7,1,3,5,7,9,11,13,15,1]\n-- ---------------------------------------------------------------------\n\njosefo1 :: Int -> Int -> Int\njosefo1 n m = head (last (sucesionJ n m))\n\n-- ---------------------------------------------------------------------\n-- \u00a7 2\u00aa soluci\u00f3n (sin la sucesi\u00f3n de estados)                         --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 4. Definir la funci\u00f3n\n--    josefo2 :: Integer -> Integer -> Integer\n-- tal que (josefo2 n m) es igual a (josefo1 n m), pero con una\n-- definici\u00f3n recursiva sin necesidad de sucesionJ. Por ejemplo,\n--    ghci> josefo2 4 2\n--    1\n--    ghci> josefo2 5 2\n--    3\n--    ghci> [josefo2 n 2 | n <- [1..16]]\n--    [1,1,3,1,3,5,7,1,3,5,7,9,11,13,15,1]\n-- ---------------------------------------------------------------------\n\njosefo2 :: Integer -> Integer -> Integer\njosefo2 n m = aux [1..n] m\n    where aux [y] _                = y\n          aux (y:ys) k | k == 1    = aux ys m\n                       | otherwise = aux (ys++[y]) (k-1)\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 5. Comparar las estad\u00edsticas para calcular\n-- (josefo1 10000 2) y (josefo2 10000 2)\n-- ---------------------------------------------------------------------\n\n-- La comparaci\u00f3n es\n--    ghci> josefo1 10000 2\n--    3617\n--    (7.40 secs, 1405343804 bytes)\n--    ghci> josefo2 10000 2\n--    3617\n--    (6.17 secs, 2096366148 bytes)\n\n-- ---------------------------------------------------------------------\n-- \u00a7 3\u00aa soluci\u00f3n (con listas circulares)                              --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 6. Los estados se pueden representar mediante listas\n-- circulares. Por ejemplo, la sucesi\u00f3n de estados del problema de\n-- Josefo con n=4 y m=2, donde con * se indica el \u00faltimo eliminado, es\n--    1 2    |  1 *    |  1      |  1         \n--    4 3    |  4 3    |  * 3    |     *\n-- que puede representarse por\n--    [([],[1,2,3,4]),([1],[3,4]),([3,1],[]),([1],[])]\n-- Para n=5 y m=2, la sucesi\u00f3n de estados es\n--    1 2 3  |  1 * 3  |  1   3  |  *   3  |      3     \n--     5 4   |   5 4   |   5 *   |   5     |   *        \n-- que se puede representar por\n--    [([],[1,2,3,4,5]),([1],[3,4,5]),([3,1],[5]),([],[3,5]),([3],[])]\n-- \n-- Definir la funci\u00f3n\n--    siguienteC :: ([Integer],[Integer]) -> Integer -> ([Integer],[Integer])\n-- tal que (siguienteC e m) es el estado siguiente del estado e\n-- salt\u00e1ndose m-1. Por ejemplo,\n--    ghci> siguienteC ([],[1..4]) 2\n--    ([1],[3,4])\n--    ghci> siguienteC ([1],[3,4]) 2\n--    ([3,1],[])\n--    ghci> siguienteC ([3,1],[]) 2\n--    ([1],[])\n--    ghci> siguienteC ([1],[]) 2\n--    ([],[1])\n--    ghci> siguienteC ([],[1]) 2\n--    ([],[1])\n-- ---------------------------------------------------------------------\n\nsiguienteC :: ([Integer],[Integer]) -> Integer -> ([Integer],[Integer])\nsiguienteC ([],[y])  _ = ([],[y])\nsiguienteC (xs,[])   m = siguienteC ([],reverse xs) m\nsiguienteC (xs,y:ys) 1 = (xs,ys)\nsiguienteC (xs,y:ys) m = siguienteC (y:xs,ys) (m-1)\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 7. Definir la funci\u00f3n\n--    sucesionJC :: Integer -> Integer -> [([Integer],[Integer])]\n-- tal que (sucesionJC n m) es la lista de los sucesivos estados del\n-- problema de Josefo con n posiciones y saltando m-1 cada vez, usando\n-- lista circulares. Por ejemplo, \n--    ghci> sucesionJC 4 2\n--    [([],[1,2,3,4]),([1],[3,4]),([3,1],[]),([1],[])]\n--    ghci> sucesionJC 5 2\n--    [([],[1,2,3,4,5]),([1],[3,4,5]),([3,1],[5]),([],[3,5]),([3],[])]\n-- ---------------------------------------------------------------------\n\nsucesionJC :: Integer -> Integer -> [([Integer],[Integer])]\nsucesionJC n m = aux ([],[1..n]) m\n    where aux ([],[y]) _ = [([],[y])]\n          aux (xs,ys)  m = (xs,ys) : aux (siguienteC (xs,ys) m) m\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 8. Definir, usando sucesionJC, la funci\u00f3n\n--    josefo3 :: Integer -> Integer -> Integer\n-- tal que (josefo3 n m) es igual a (josefo1 n m). Por ejemplo,\n--    ghci> josefo3 4 2\n--    1\n--    ghci> josefo3 5 2\n--    3\n--    ghci> [josefo3 n 2 | n <- [1..16]]\n--    [1,1,3,1,3,5,7,1,3,5,7,9,11,13,15,1]\n-- ---------------------------------------------------------------------\n\njosefo3 :: Integer -> Integer -> Integer\njosefo3 n m = head (snd (last (sucesionJC n m)))\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 9. Comparar las estad\u00edsticas para calcular\n-- (josefo2 10000 2) y (josefo3 10000 2)\n-- ---------------------------------------------------------------------\n\n-- La comparaci\u00f3n es\n--    ghci> josefo2 10000 2\n--    3617\n--    (6.37 secs, 2120477348 bytes)\n--    ghci> josefo3 10000 2\n--    3617\n--    (0.11 secs, 4139408 bytes)\n\n-- ---------------------------------------------------------------------\n-- \u00a7 4\u00aa soluci\u00f3n (con listas circulares sin la sucesi\u00f3n de estados)   --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 10. Definir, usando listas circulares pero no sucesionJC,\n-- la funci\u00f3n \n--    josefo4 :: Integer -> Integer -> Integer\n-- tal que (josefo4 n m) es igual a (josefo1 n m). Por ejemplo,\n--    ghci> josefo4 4 2\n--    1\n--    ghci> josefo4 5 2\n--    3\n--    ghci> [josefo4 n 2 | n <- [1..16]]\n--    [1,1,3,1,3,5,7,1,3,5,7,9,11,13,15,1]\n-- ---------------------------------------------------------------------\n\njosefo4 :: Integer -> Integer -> Integer\njosefo4 n m = aux ([],[1..n]) m\n    where aux ([],[y]) _  = y\n          aux (xs,[]) k   = aux ([],reverse xs) k\n          aux (xs,y:ys) 1 = aux (xs,ys) m\n          aux (xs,y:ys) k = aux (y:xs,ys) (k-1)\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 11. Comparar las estad\u00edsticas para calcular\n-- (josefo3 100000 2) y (josefo4 100000 2)\n-- ---------------------------------------------------------------------\n\n-- La comparaci\u00f3n es\n--    ghci> josefo3 100000 2\n--    68929\n--    (0.87 secs, 37726352 bytes)\n--    ghci> josefo4 100000 2\n--    68929\n--    (0.65 secs, 28423336 bytes)\n\n-- ---------------------------------------------------------------------\n-- \u00a7 5\u00aa soluci\u00f3n (por recursi\u00f3n sin listas para m=2)                  --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 12. Calcular las listas de los valores de (josefo1 n 2)\n-- para n en  {1,2,...,20} y para n en {2,4,...,40}. \u00bfQu\u00e9 relaci\u00f3n se\n-- observa entre los elementos de ambas listas con la misma posici\u00f3n? \u00bfy\n-- entre  (josefo1 n 2) y (josefo1 (n `div` 2) 2), cuando n es par?\n-- ---------------------------------------------------------------------\n\n-- El c\u00e1lculo es\n--    ghci> [josefo1 n 2 | n <- [1..20]]\n--    [1,1,3,1,3,5,7,1,3,5,7,9,11,13,15,1,3,5,7,9]\n--    ghci> [josefo1 n 2 | n <- [2,4..40]]\n--    [1,1,5,1,5,9,13,1,5,9,13,17,21,25,29,1,5,9,13,17]\n--\n-- Se observa que si x es el elemento de la primera lista en la posici\u00f3n\n-- n e y es el elemento de la segunda lista en la posici\u00f3n n, entonces \n-- y = 2*x-1. Es decir, como los \u00edndice de la segunda lista son los\n-- n\u00fameros pares y los de la primera son sus mitades, se tiene que\n--    josefo1 n 2 = 2 * (josefo1 (n `div` 2) 2) - 1\n    \n-- ---------------------------------------------------------------------\n-- Ejercicio 13. Calcular las listas de los valores de (josefo1 n 2)\n-- para n en  {1,2,...,20} y para n en {3,5,...,41}. \u00bfQu\u00e9 relaci\u00f3n se\n-- observa entre los elementos de ambas listas con la misma posici\u00f3n? \u00bfy\n-- entre  (josefo1 n 2) y (josefo1 (n `div` 2 2), cuando n es impar?\n-- ---------------------------------------------------------------------\n\n-- El c\u00e1lculo es\n--    ghci> [josefo1 n 2 | n <- [1..20]]\n--    [1,1,3,1,3,5,7,1,3,5,7,9,11,13,15,1,3,5,7,9]\n--    ghci> [josefo1 n 2 | n <- [3,5..41]]\n--    [3,3,7,3,7,11,15,3,7,11,15,19,23,27,31,3,7,11,15,19]\n--\n-- Se observa que si x es el elemento de la primera lista en la posici\u00f3n\n-- n e y es el elemento de la segunda lista en la posici\u00f3n n, entonces \n-- y = 2*x-1. Es decir, como los \u00edndice de la segunda lista son los\n-- n\u00fameros impares y los de la primera son sus mitades enteras, se tiene\n-- que \n--    josefo1 n 2 = 2 * (josefo1 (n `div` 2) 2) + 1\n    \n-- ---------------------------------------------------------------------\n-- Ejercicio 14. Usando las anteriores relaciones, definir la funci\u00f3n\n--    josefo5 :: Integer -> Integer\n-- tal que (josefo5 n) es igual a (josefo1 n 2). Por ejemplo,\n--    ghci> josefo5 4\n--    1\n--    ghci> josefo5 5\n--    3\n--    ghci> [josefo5 n | n <- [1..16]]\n--    [1,1,3,1,3,5,7,1,3,5,7,9,11,13,15,1]\n-- ---------------------------------------------------------------------\n\njosefo5 :: Integer -> Integer\njosefo5 n | n < 3     = 1\n          | even n    = 2 * josefo5 (n `div` 2) - 1\n          | otherwise = 2 * josefo5 (n `div` 2) + 1\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 15. Comparar las estad\u00edsticas para calcular\n-- (josefo4 100000 2) y (josefo5 100000)\n-- ---------------------------------------------------------------------\n\n-- La comparaci\u00f3n es\n--    ghci> josefo4 100000 2\n--    68929\n--    (0.64 secs, 28424448 bytes)\n--    ghci> josefo5 100000\n--    68929\n--    (0.01 secs, 517940 bytes)\n\n-- ---------------------------------------------------------------------\n-- \u00a7 6\u00aa soluci\u00f3n (por recursi\u00f3n sin listas)                           --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 16. Calcular los siguientes listas de los valores \n--    (josefo1 n 3) y (((josefo1 (n-1) 3) + 2) `rem` n + 1) \n--    (josefo1 n 4) y (((josefo1 (n-1) 4) + 3) `rem` n + 1) \n--    (josefo1 n 5) y (((josefo1 (n-1) 5) + 4) `rem` n + 1) \n-- para n en  {2,3,...,20}. \u00bfQu\u00e9 relaci\u00f3n se observa entre los elementos\n-- de ambas listas con la misma posici\u00f3n? \u00bfy entre (josefo1 n m) y \n-- (((josefo1 (n-1) ) + m - 1) `rem` n + 1)? \n-- ---------------------------------------------------------------------\n\n-- El c\u00e1lculo es\n--    ghci> [josefo1 n 3 | n <- [2..20]]\n--    [2,2,1,4,1,4,7,1,4,7,10,13,2,5,8,11,14,17,20]\n--    ghci> [((josefo1 (n-1) 3) + 2) `rem` n + 1 | n <- [2..20]]\n--    [2,2,1,4,1,4,7,1,4,7,10,13,2,5,8,11,14,17,20]\n--    ghci> [josefo1 n 4 | n <- [2..20]]\n--    [1,2,2,1,5,2,6,1,5,9,1,5,9,13,1,5,9,13,17]\n--    ghci> [((josefo1 (n-1) 4) + 3) `rem` n + 1 | n <- [2..20]]\n--    [1,2,2,1,5,2,6,1,5,9,1,5,9,13,1,5,9,13,17]\n--    ghci> [josefo1 n 5 | n <- [2..20]]\n--    [2,1,2,2,1,6,3,8,3,8,1,6,11,1,6,11,16,2,7]\n--    ghci> [((josefo1 (n-1) 5) + 4) `rem` n + 1 | n <- [2..20]]\n--    [2,1,2,2,1,6,3,8,3,8,1,6,11,1,6,11,16,2,7]\n--\n-- Se observa que tienen los mismos valores. Por tanto,\n--    josefo1 n m = ((josefo1 (n-1) ) + m - 1) `rem` n + 1\n    \n-- ---------------------------------------------------------------------\n-- Ejercicio 17. Usando la anterior relaci\u00f3n, definir la funci\u00f3n\n--    josefo6 :: Integer -> Integer -> Integer\n-- tal que (josefo6 n m) es igual a (josefo1 n m). Por ejemplo,\n--    ghci> [josefo6 n 2 | n <- [1..16]]\n--    [1,1,3,1,3,5,7,1,3,5,7,9,11,13,15,1]\n-- ---------------------------------------------------------------------\n\njosefo6 :: Integer -> Integer -> Integer\njosefo6 1 _ = 1\njosefo6 n m = (josefo6 (n-1) m + m - 1) `rem` n + 1\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 18. Comparar las estad\u00edsticas para calcular\n-- (josefo1 10000 3) y (josefo6 10000 3)\n-- ---------------------------------------------------------------------\n\n-- La comparaci\u00f3n es\n--    ghci> josefo1 10000 3\n--    2692\n--    (7.47 secs, 1405392756 bytes)\n--    ghci> josefo6 10000 3\n--    2692\n--    (0.08 secs, 2756452 bytes)\n\n-- ---------------------------------------------------------------------\n-- \u00a7 7\u00aa soluci\u00f3n (sin recursi\u00f3n para m=2)                  --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 19. Calcular el valor de (josefo5 (2^m)) para m entre 1 y\n-- 20. \u00bfQu\u00e9 se observa?\n-- --------------------------------------------------------------------- \n\n-- El c\u00e1lculo es\n--    ghci> [josefo5 (2^m) | m <- [1..20]]\n--    [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]\n--\n-- Se observa que (josefo5 (2^m)) = 1.\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 20. Calcular el valor de (josefo5 (2^4+k)) para k entre 0 y\n-- 2^4-1. \u00bfQu\u00e9 se observa?\n-- --------------------------------------------------------------------- \n\n-- El c\u00e1lculo es\n--    ghci> [josefo5 (2^4+k) | k <- [0..2^4-1]]\n--    [1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31]\n--\n-- Se observa que (josefo5 (2^4+k) = 2*k+1. En efecto,\n--    ghci> and [josefo5 (2^4+k) == 2*k+1 | k <- [0..2^4-1]]\n--    True\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 21. Calcular el valor de (josefo5 (2^5+k)) para k entre 0 y\n-- 2^5-1. \u00bfQu\u00e9 se observa?\n-- --------------------------------------------------------------------- \n\n-- El c\u00e1lculo es\n--    ghci> [josefo5 (2^5+k) | k <- [0..2^5-1]]\n--    [1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35,37,39,41,43,45,\n--     47,49,51,53,55,57,59,61,63]\n--\n-- Se observa que (josefo5 (2^5+k) = 2*k+1. En efecto,\n--    ghci> and [josefo5 (2^5+k) == 2*k+1 | k <- [0..2^5-1]]\n--    True\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 22. Usando las anteriores relaciones, definir sin usar\n-- recursi\u00f3n, la funci\u00f3n\n--    josefo7 :: Integer -> Integer\n-- tal que (josefo7 n) es igual a (josefo5 n). Por ejemplo,\n--    ghci> josefo7 4\n--    1\n--    ghci> josefo7 5\n--    3\n--    ghci> [josefo7 n | n <- [1..16]]\n--    [1,1,3,1,3,5,7,1,3,5,7,9,11,13,15,1]\n-- ---------------------------------------------------------------------\n\njosefo7 :: Integer -> Integer\njosefo7 n = 2*(n-2^m)+1\n    where m = floor (logBase 2 (fromIntegral n))\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 23. Comparar las estad\u00edsticas para calcular las siguientes\n-- expresiones \n--    head [n | n <- [1..], josefo5 n > 100000]\n--    head [n | n <- [1..], josefo7 n > 100000]\n-- ---------------------------------------------------------------------\n\n-- La comparaci\u00f3n es\n--    ghci> head [n | n <- [1..], josefo5 n > 100000]\n--    115536\n--    (10.43 secs, 418120368 bytes)\n--    ghci> head [n | n <- [1..], josefo7 n > 100000]\n--    115536\n--    (2.98 secs, 183530188 bytes)\n<\/pre>\n","protected":false},"excerpt":{"rendered":"<p>El problema de Josefo hace referencia a Flavio Josefo, un historiador jud\u00edo que vivi\u00f3 en el siglo I. Seg\u00fan lo que cuenta Josefo, \u00e9l y cuarenta soldados camaradas fueron capturados por los romanos. Antes que rendirse, decidieron acabar ellos mismos con sus vidas. Para hacerlo, se dispusieron en un c\u00edrculo y acordaron que ir\u00edan contando&#8230;<\/p>\n","protected":false},"author":2,"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":[5,221],"tags":[270,299],"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\/3950"}],"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=3950"}],"version-history":[{"count":6,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/3950\/revisions"}],"predecessor-version":[{"id":5274,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/3950\/revisions\/5274"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=3950"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=3950"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=3950"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}