{"id":3496,"date":"2013-08-14T16:01:23","date_gmt":"2013-08-14T16:01:23","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=3496"},"modified":"2013-08-31T06:53:13","modified_gmt":"2013-08-31T06:53:13","slug":"los-numeros-de-ulam-en-haskell","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/los-numeros-de-ulam-en-haskell\/","title":{"rendered":"Los n\u00fameros de Ulam en Haskell"},"content":{"rendered":"

Los n\u00fameros de Ulam<\/a> son los elementos de la sucesi\u00f3n u(n) definida por u(1) = 1, u(2) = 2 y, para n > 2, u(n) es el entero m\u00e1s peque\u00f1o que se puede escribir exactamente de una forma como suma de dos t\u00e9rminos anteriores diferentes entre s\u00ed.<\/p>\n

Seg\u00fan la definici\u00f3n, 3=1+2 es un n\u00famero de Ulam y 4=1+3 tambi\u00e9n es un n\u00famero de Ulam (la suma 4=2+2 no cuenta porque los t\u00e9rminos previos deben ser distintos). El entero 5 no es un n\u00famero de Ulam porque 5=1+4=2+3.<\/p>\n

Los primeros t\u00e9rminos de la sucUlam son: 1, 2, 3, 4, 6, 8, 11, 13, 16, 18, 26, 28, 36, 38, 47, 48, 53, 57, 62, 69, 72, 77, 82, 87, 97, 99. <\/p>\n

Esta sucesi\u00f3n fue definida por el matem\u00e1tico polaco Stanislaw Ulam<\/a> y
\npublicada en SIAM Review en 1964. <\/p>\n

A partir de los art\u00edculos de la Wikipedia<\/a> y de MathWorld<\/a> sobre los n\u00fameros de Ulam elaborado la siguiente relaci\u00f3n de ejercicios de Haskell para la asignatura de Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas<\/a>.<\/p>\n

En la relaci\u00f3n se presentan cuatro definiciones de los n\u00fameros de Ulam, se compara su eficiencia, se muestra algunas de sus propiedades terminando con los n\u00fameros de Ulam generalizados.
\n<\/p>\n

\r\n-- ---------------------------------------------------------------------\r\n-- Librer\u00edas auxiliares\r\n-- ---------------------------------------------------------------------\r\n\r\nimport Graphics.Gnuplot.Simple\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicios\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1. Definir la funci\u00f3n\r\n--    sumas :: Integer -> [Integer] -> [(Integer,Integer)]\r\n-- tal que (sumas x ys) es la lista de pares de elementos de\r\n-- la lista ordenada ys cuya suma es x. Por ejemplo,\r\n--    sumas 3  [1,2]           ==  [(1,2)]\r\n--    sumas 4  [1,2,3]         ==  [(1,3)]\r\n--    sumas 5  [1,2,3,4]       ==  [(1,4),(2,3)]\r\n--    sumas 6  [1,2,3,4]       ==  [(2,4)]\r\n--    sumas 7  [1,2,3,4,6]     ==  [(1,6),(3,4)]\r\n--    sumas 8  [1,2,3,4,6]     ==  [(2,6)]\r\n--    sumas 9  [1,2,3,4,6,8]   ==  [(1,8),(3,6)]\r\n--    sumas 10 [1,2,3,4,6,8]   ==  [(2,8),(4,6)]\r\n--    sumas 11 [1,2,3,4,6,8]   ==  [(3,8)]\r\n-- ---------------------------------------------------------------------\r\n\r\nsumas :: Integer -> [Integer] -> [(Integer,Integer)]\r\nsumas x ys = [(a,x-a) | a <- zs, (x-a) `elem` dropWhile (<=a) zs]\r\n    where zs = takeWhile ( Integer\r\n-- tal que (ulam n) es el n-\u00e9simo n\u00famero de Ulam. Por ejemplo,\r\n--    ghci> [ulam n | n <- [1..20]]\r\n--    [1,2,3,4,6,8,11,13,16,18,26,28,36,38,47,48,53,57,62,69]\r\n-- ---------------------------------------------------------------------\r\n\r\nulam :: Int -> Integer\r\nulam 1 = 1\r\nulam 2 = 2\r\nulam n = head [x | x <- [u+1..], length (sumas x us) == 1]\r\n    where us = [ulam i | i <- [1..n-1]]\r\n          u  = last us\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 3. Definir, usando la funci\u00f3n ulam, la constante\r\n--    sucUlam :: [Integer]\r\n-- cuyos elementos son los n\u00fameros de Ulman. Por ejemplo,\r\n--    ghci> take 20 sucUlam\r\n--    [1,2,3,4,6,8,11,13,16,18,26,28,36,38,47,48,53,57,62,69]\r\n-- ---------------------------------------------------------------------\r\n\r\nsucUlam :: [Integer]\r\nsucUlam = [ulam n | n <- [1..]]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 4. Definir, sin usar la funci\u00f3n ulam, la constante\r\n--    sucUlam2 :: [Integer]\r\n-- cuyos elementos son los n\u00fameros de Ulman. Por ejemplo,\r\n--    ghci> take 20 sucUlam2\r\n--    [1,2,3,4,6,8,11,13,16,18,26,28,36,38,47,48,53,57,62,69]\r\n-- ---------------------------------------------------------------------\r\n\r\nsucUlam2 :: [Integer]\r\nsucUlam2 = 1 : 2 : aux 2 2 where \r\n    aux n u = u' : aux (n+1) u' where \r\n       u' = head [x | x <- [u+1..], \r\n                      length (sumas x (take n sucUlam2)) == 1]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 5. Definir la funci\u00f3n\r\n--    ulam2 :: Int -> Integer\r\n-- tal que (ulam4 n) es el n-\u00e9simo n\u00famero de Ulam. Por ejemplo,\r\n--    ulam2 20  ==  69\r\n-- ---------------------------------------------------------------------\r\n\r\nulam2 :: Int -> Integer\r\nulam2 n = sucUlam2 !! (n-1)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 6. Comparar la eficiencia de ulam y ulam2 calculando\r\n-- el 20-\u00e9simo n\u00famero de Ulam.\r\n-- ---------------------------------------------------------------------\r\n\r\n-- La comparaci\u00f3n es\r\n--    ghci> :set +s\r\n--    ghci> ulam 20\r\n--    69\r\n--    (3.43 secs, 247050284 bytes)\r\n--    ghci> ulam2 20\r\n--    69\r\n--    (0.01 secs, 0 bytes)\r\n-- \r\n-- Se observa que sucUlam2 es m\u00e1s eficiente que sucUlam.\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 7. Definir la funci\u00f3n\r\n--    nSumas :: Integer -> [Integer] -> Int\r\n-- tal que (nSumas x ys) es el n\u00famero de expresar x como suma de un par\r\n-- de elementos distintos de la sucesi\u00f3n creciente ys. Por ejemplo, \r\n--    nSumas 11 [2,4,5,6,7,9,11,12]  ==  3\r\n-- ---------------------------------------------------------------------\r\n\r\nnSumas :: Integer -> [Integer] -> Int\r\nnSumas _ [] = 0\r\nnSumas x (y:ys) | x-y <= y        = 0\r\n                | (x-y) `elem` ys = 1 + nSumas x ys\r\n                | otherwise       = nSumas x ys\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 8. Definir, usando la funci\u00f3n nSumas, la constante\r\n--    sucUlam3 :: [Integer]\r\n-- cuyos elementos son los n\u00fameros de Ulman. Por ejemplo,\r\n--    ghci> take 20 sucUlam3\r\n--    [1,2,3,4,6,8,11,13,16,18,26,28,36,38,47,48,53,57,62,69]\r\n-- ---------------------------------------------------------------------\r\n\r\nsucUlam3 :: [Integer]\r\nsucUlam3 = 1 : 2 : aux 2 2 where \r\n    aux n u = u' : aux (n+1) u' where\r\n       u' = head [x | x <- [u+1..], \r\n                      nSumas x (take n sucUlam3) == 1]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 9. Definir la funci\u00f3n\r\n--    ulam3 :: Int -> Integer\r\n-- tal que (ulam4 n) es el n-\u00e9simo n\u00famero de Ulam. Por ejemplo,\r\n--    ulam3 20  ==  69\r\n-- ---------------------------------------------------------------------\r\n\r\nulam3 :: Int -> Integer\r\nulam3 n = sucUlam3 !! (n-1)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 10. Comparar la eficiencia de ulam2 y ulam3 calculando\r\n-- el 200-\u00e9simo n\u00famero de Ulam.\r\n-- ---------------------------------------------------------------------\r\n\r\n-- La comprobaci\u00f3n es\r\n--    ghci> ulam2 200\r\n--    1792\r\n--    (3.48 secs, 35527792 bytes)\r\n--    ghci> ulam3 200\r\n--    1792\r\n--    (0.54 secs, 27636396 bytes)\r\n-- \r\n-- Se observa que sucUlam3 es m\u00e1s eficiente que sucUlam2.\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 11. Definir la funci\u00f3n\r\n--    expresable :: Int -> Integer -> [Integer] -> Bool\r\n-- tal que (expresable n x ys) se verifica si x se puede escribir como\r\n-- suma de pares de elementos de la sucesi\u00f3n creciente ys exactamente de\r\n-- n formas. Por ejemplo,\r\n--    expresable 1 3 [1,2]      ==  True\r\n--    expresable 1 5 [1,2,3,4]  ==  False\r\n--    expresable 2 5 [1,2,3,4]  ==  True\r\n-- ---------------------------------------------------------------------\r\n\r\nexpresable :: Int -> Integer -> [Integer] -> Bool\r\nexpresable 0 _ []                       = True\r\nexpresable 0 x (y:ys) | x-y <= y        = True \r\n                      | (x-y) `elem` ys = False\r\n                      | otherwise       = expresable 0 x ys\r\nexpresable _ x []                       = False\r\nexpresable n x (y:ys) | x-y <= y        = False\r\n                      | (x-y) `elem` ys = expresable (n-1) x ys\r\n                      | otherwise       = expresable n x ys\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 12. Definir, usando la funci\u00f3n expresable, la constante\r\n--    sucUlam4 :: [Integer]\r\n-- cuyos elementos son los n\u00fameros de Ulman. Por ejemplo,\r\n--    ghci> take 20 sucUlam4\r\n--    [1,2,3,4,6,8,11,13,16,18,26,28,36,38,47,48,53,57,62,69]\r\n-- ---------------------------------------------------------------------\r\n\r\nsucUlam4 :: [Integer]\r\nsucUlam4 = 1 : 2 : aux 2 2  \r\n    where aux n u = u' : aux (n+1) u' \r\n              where u' = head [x | x <- [1+u..], \r\n                                   expresable 1 x (take n sucUlam4)]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 13. Definir la funci\u00f3n\r\n--    ulam4 :: Int -> Integer\r\n-- tal que (ulam4 n) es el n-\u00e9simo n\u00famero de Ulam. Por ejemplo,\r\n--    ulam4 20  ==  69\r\n-- ---------------------------------------------------------------------\r\n\r\nulam4 :: Int -> Integer\r\nulam4 n = sucUlam4 !! (n-1)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 14. Comparar la eficiencia de ulam3 y ulam4 calculando el\r\n-- 500-\u00e9simo n\u00famero de Ulam.\r\n-- ---------------------------------------------------------------------\r\n\r\n-- La comprobaci\u00f3n es\r\n--    ghci> ulam3 500\r\n--    5685\r\n--    (6.33 secs, 202163168 bytes)\r\n--    ghci> ulam4 500\r\n--    5685\r\n--    (2.42 secs, 104099404 bytes)\r\n-- \r\n-- Se observa que sucUlam4 es m\u00e1s eficiente que sucUlam3.\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 15. Definir la funci\u00f3n\r\n--    dibujoSucUlam :: Int -> IO ()\r\n-- tal que (dibujoSucUlam n) representa los n primeros t\u00e9rminos de la\r\n-- sucesi\u00f3n de Ulam. Por ejemplo, el dibujo de los 10 y 1000 primeros\r\n-- t\u00e9rminos se presenta en las figuras 1 y 2, respectivamente, en el\r\n-- final de la relaci\u00f3n\r\n-- ---------------------------------------------------------------------\r\n\r\ndibujoSucUlam :: Int -> IO ()\r\ndibujoSucUlam n = \r\n    plotList [Title (show n ++ \" primeros numeros de Ulam\"),\r\n              PNG (\"Fig_dibujoSucUlam_\" ++ show n ++ \".png\"),\r\n              YLabel \"Ulam(n)\", \r\n              Key Nothing] \r\n             (take n sucUlam4) \r\n\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 16. Definir la funci\u00f3n\r\n--    dibujoSucUlamAproxLin :: Int -> Int -> Int -> IO ()\r\n-- tal que (dibujoSucUlamAproxLin a b n) dibuja los n primeros t\u00e9rminos\r\n-- de la sucesi\u00f3n de Ulam y las rectas y=a*x e y=b*x.\r\n--\r\n-- Encontrar dos pendientes a y b tales que la sucesi\u00f3n de\r\n-- Ulam tienda a estar entre las rectas y=a*x e y=b*x\r\n-- ---------------------------------------------------------------------\r\n\r\ndibujoSucUlamAproxLin :: Int -> Int -> Int -> IO ()\r\ndibujoSucUlamAproxLin a b n = \r\n    plotFuncs [Title (\"Aproximacion lineal de numeros de Ulam\"),\r\n               PNG (\"Fig_Aproximacion_lineal_Ulam.png\"),\r\n               YLabel \"Ulam(n)\", \r\n               Key Nothing]\r\n              [1..n] \r\n              [fromIntegral . ulam4,\r\n               \\x -> a*x,\r\n               \\x -> b*x]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 17. La densidad de un conjunto de n\u00fameros naturales A es el\r\n-- l\u00edmite de a(n)\/n, donde a(n) es el n\u00famero de elementos de A menores o\r\n-- iguales que n.\r\n-- \r\n-- Definir la funci\u00f3n \r\n--    densidadU :: Integer -> Double\r\n-- tal que (densidadU n) es a(n)\/n, donde a(n) es la cantidad de n\u00fameros\r\n-- de Ulam menores o iguales que n. Por ejemplo,\r\n--    densidad 100  ==  0.26\r\n-- Calcular (densidad 30000).\r\n-- ---------------------------------------------------------------------\r\n \r\ndensidadU :: Integer -> Double\r\ndensidadU n = \r\n    (fromIntegral (length (takeWhile (<=n) sucUlam4))) \/ (fromIntegral n)\r\n\r\n-- El c\u00e1lculo es\r\n--    ghci> densidad 30000\r\n--    7.796666666666667e-2\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 18. Definir la funci\u00f3n\r\n--    dibujoDensidadU :: Integer -> Integer -> IO ()\r\n-- tal que (dibujoDensidadU a b) es la densidad de los t\u00e9rminos de la\r\n-- sucesi\u00f3n de Ulman entre los lugares a y b. Por ejemplo, \r\n-- (dibujoDensidadU 1 3000) genera la figura 4.\r\n-- ---------------------------------------------------------------------\r\n\r\ndibujoDensidadU :: Integer -> Integer -> IO ()\r\ndibujoDensidadU a b = \r\n    plotList \r\n      [Title (\"Densidad Ulam entre \" ++ show a ++ \" y \" ++ show b),\r\n       PNG (\"Fig_DensidadUlam_\" ++ show a ++ \"-\" ++ show b ++ \".png\"),\r\n       YLabel \"DendidadUlam(n)\", \r\n       Key Nothing]\r\n      [densidadU n | n <- [a..b]]\r\n\r\n--  Nota. La densidad de la sucesi\u00f3n de Ulman tiende a 0.07396.\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 19. Definir la funci\u00f3n\r\n--    ulamConsecutivos :: Integer -> [Integer]\r\n-- tal que (ulamConsecutivos n) es la lista de los n\u00fameros de Ulam x\r\n-- tales que x+1 tambi\u00e9n es un n\u00famero de Ulam. Por ejemplo,\r\n--    ulamConsecutivos 1000  ==  [1,2,3,47]\r\n-- ---------------------------------------------------------------------\r\n\r\nulamConsecutivos :: Integer -> [Integer]\r\nulamConsecutivos n = \r\n    [x | (x,y) <- zip us (tail us), y == x+1]\r\n    where us = takeWhile (<= n) sucUlam4\r\n\r\n-- Nota. Los \u00fanicos n\u00fameros de Ulam, menores que 6.759*10^8, cuyo\r\n-- consecutivos son tambi\u00e9n n\u00fameros de Ulam son 1, 2, 3 y 47.\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 20. Definir la funci\u00f3n \r\n--    posicion :: Integer -> Int\r\n-- tal que (posicion u) es la posici\u00f3n del n\u00famero de Ullman u dentro de\r\n-- la sucesi\u00f3n. Por ejemplo,\r\n--    posicion 6  ==  5\r\n--    ulam4 5     ==  6\r\n-- ---------------------------------------------------------------------\r\n\r\nposicion :: Integer -> Int\r\nposicion n = length (takeWhile (<=n) sucUlam4)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 21. Definir la funci\u00f3n \r\n--    primerHueco :: Integer -> Int\r\n-- tal que (primerHueco a) es la primara posici\u00f3n n tal que la\r\n-- diferencia entre el (n+1)-\u00e9simo n\u00famero de Ulam y el n-\u00e9simo es mayor\r\n-- que a. Por ejemplo,\r\n--    primerHueco 10  ==  29\r\n--    ulam4 29        ==  114\r\n--    ulam4 30        ==  126\r\n-- ---------------------------------------------------------------------\r\n\r\nprimerHueco :: Integer -> Int\r\nprimerHueco a =\r\n    head [posicion x | (x,y) <- zip us (tail us), y-x > a]\r\n    where us = sucUlam4\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 22. Definir la funci\u00f3n\r\n--    mayorHueco :: Integer -> (Integer,Integer)\r\n-- tal que (mayorHueco n) es el par (d,m) tal que d es la mayor\r\n-- distancia entre dos n\u00fameros de Ulam consecutivos menores con posici\u00f3n\r\n-- menor o igual que n y dicha distancia es la que hay entre los\r\n-- t\u00e9rminos m y m+1 de la sucesi\u00f3n. Por ejemplo,\r\n--    mayorHueco 100  ==  (27,77)\r\n--    ulam4 77        ==  456\r\n--    ulam4 78        ==  483\r\n-- Calcular el mayor hueco hasta el t\u00e9rmino 5.000-\u00e9simo\r\n-- ---------------------------------------------------------------------\r\n\r\nmayorHueco :: Int -> (Integer,Int)\r\nmayorHueco n =\r\n    maximum [(y-x,posicion x) | (x,y) <- zip us (tail us)]\r\n    where us = take n sucUlam4\r\n\r\n-- El c\u00e1lculo es\r\n--    ghci> mayorHueco 5000\r\n--    (262,4952)\r\n--    ghci> ulam4 4952\r\n--    64420\r\n--    ghci> ulam4 4953\r\n--    64682\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 23. La sucesi\u00f3n de Ulam se puede generalizar cambiando los\r\n-- dos primeros t\u00e9rminos por dos n\u00fameros a y b. La sucesi\u00f3n obtenida se\r\n-- llama la suceci\u00f3n de Ulam (a,b). Por ejemplo, los primeros t\u00e9rminos\r\n-- de la sucesi\u00f3n de Ulam (2,5) son \r\n--    2, 5, 7, 9, 11, 12, 13, 15, 19, 23, ...\r\n-- \r\n-- Definir la funci\u00f3n\r\n--    sucUlamG :: Integer -> Integer -> [Integer]\r\n-- tal que (sucUlamG a b) es la sucesi\u00f3n de Ulam (a,b). Por ejemplo,\r\n--    take 10 (sucUlamG 1 2)  ==  [1,2,3,4,6,8,11,13,16,18]\r\n--    take 10 (sucUlamG 1 3)  ==  [1,3,4,5,6,8,10,12,17,21]\r\n--    take 10 (sucUlamG 1 4)  ==  [1,4,5,6,7,8,10,16,18,19]\r\n--    take 10 (sucUlamG 1 5)  ==  [1,5,6,7,8,9,10,12,20,22]\r\n--    take 10 (sucUlamG 2 3)  ==  [2,3,5,7,8,9,13,14,18,19]\r\n--    take 10 (sucUlamG 2 4)  ==  [2,4,6,8,12,16,22,26,32,36]\r\n--    take 10 (sucUlamG 2 5)  ==  [2,5,7,9,11,12,13,15,19,23]\r\n-- ---------------------------------------------------------------------\r\n\r\nsucUlamG :: Integer -> Integer ->[Integer]\r\nsucUlamG a b = a : b : aux 2 b \r\n    where us = sucUlamG a b\r\n          aux n u = u' : aux (n+1) u' \r\n              where u' = head [x | x <- [1+u..], \r\n                                   expresable 1 x (take n us)]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 24. Definir la funci\u00f3n\r\n--    pares :: Integer -> Integer -> Int  -> [Integer]\r\n-- tal que (pares a b) es la lista de los t\u00e9rminos de la sucesi\u00f3n de\r\n-- Ulam (a,b), de posici\u00f3n hasta n, que son pares. Por ejemplo,\r\n--    pares 1 2 20  ==  [2,4,6,8,16,18,26,28,36,38,48,62]\r\n--    pares 1 3 20  ==  [4,6,8,10,12,28,32,34,48,52,54]\r\n--    pares 1 5 20  ==  [6,8,10,12,20,22,24,26,38,40,52]\r\n--    pares 2 3 20  ==  [2,8,14,18,24,30,36,40,46]\r\n--    pares 2 5 20  ==  [2,12]\r\n-- ---------------------------------------------------------------------\r\n\r\npares :: Integer -> Integer -> Int  -> [Integer]\r\npares a b n = [x | x <- take n (sucUlamG a b), even x] \r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 25. Calcular los t\u00e9rminos de la lista de los 100 primeros\r\n-- n\u00fameros de Ulam (2,b) para b = 5, 7 y 9. \r\n-- \r\n-- Conjeturar su valor para cualquier n\u00famero impar b mayor o igual que\r\n-- 5. \r\n-- ---------------------------------------------------------------------\r\n\r\n-- El c\u00e1lculo es\r\n--     pares 2 5 100  ==  [2,12]\r\n--     pares 2 7 100  ==  [2,16]\r\n--     pares 2 9 100  ==  [2,20]\r\n\r\n-- La conjetura es que los pares de la sucesi\u00f3n de Ulam (2,b), con b\r\n-- impar mayor que 5, son 2 y 2+2*b. Es decir,\r\nconjetura2b :: Integer -> Bool\r\nconjetura2b b = pares 2 b 100 == [2,2+2*b]\r\n\r\n-- La comprobaci\u00f3n es\r\n--    ghci> and [conjetura2b b | b <- [5,7..29]]\r\n--    True\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 26. Calcular los t\u00e9rminos de la lista de los 100 primeros\r\n-- n\u00fameros de Ulam (4,b) para b = 5, 9, 13. \r\n-- \r\n-- Conjeturar su valor para cualquier n\u00famero impar b mayor o igual que\r\n-- 5. \r\n-- ---------------------------------------------------------------------\r\n\r\n-- El c\u00e1lculo es\r\n--    pares 4  5 100  ==  [4,14,24]\r\n--    pares 4  9 100  ==  [4,22,40]\r\n--    pares 4 13 100  ==  [4,30,56]\r\n\r\n-- La conjetura es que los pares de la sucesi\u00f3n de Ulam (4,b), con b\r\n-- mayor que 5 y congruente con 1 m\u00f3dulo 4, son 4, 4+2*b y 4+4*b. Es\r\n-- decir, \r\nconjetura4b :: Integer -> Bool\r\nconjetura4b b = pares 4 b 50 == [4,4+2*b,4+4*b]\r\n\r\n-- La comprobaci\u00f3n es\r\n--    ghci> and [conjetura4b b | b <- [5,9..21]]\r\n--    True\r\n\r\n{- ---------------------------------------------------------------------\r\n Nota. A continuaci\u00f3n se muestran las figuras de los ejercicios 15, 16 y\r\n 18. Para verlas en emacs, usar M-x iimage-mode\r\n\r\n Figura 1: 10 primeros n\u00fameros de Ulam calculados con \r\n (dibujoSucUlam 10)\r\n    Fig_dibujoSucUlam_10.png\r\n\r\n Figura 2: 1000 primeros n\u00fameros de Ulam calculados con \r\n (dibujoSucUlam 1000)\r\n    Fig_dibujoSucUlam_1000.png\r\n\r\n Figura 3: Aproximaciones lineales de la sucesi\u00f3n de Ulam calculadas con \r\n (dibujoSucUlamAproxLin 12 14 3000)\r\n    Fig_Aproximacion_lineal_Ulam.png\r\n\r\n Figura 4: Densidad de la sucesi\u00f3n de Ulam calculada con \r\n (dibujoDensidadU 1 3000)\r\n    Fig_DensidadUlam_1-3000.png\r\n -------------------------------------------------------------------- -}\r\n<\/pre>\n
A continuaci\u00f3n se muestran las figuras de los ejercicios 15, 16 y 18.<\/p>\n
    \n
  •  Figura 1: 10 primeros n\u00fameros de Ulam calculados con
    \n(dibujoSucUlam 10)
    \n
    \"Fig.1:
    Fig.1: 10 primeros n\u00fameros de Ulam<\/figcaption><\/figure><\/p>\n
  •  Figura 2: 1000 primeros n\u00fameros de Ulam calculados con
    \n(dibujoSucUlam 1000)
    \n
    \"Fig.
    Fig. 2: 1000 primeros n\u00fameros de Ulam<\/figcaption><\/figure><\/p>\n
  •  Figura 3: Aproximaciones lineales de la sucesi\u00f3n de Ulam calculadas con
    \n(dibujoSucUlamAproxLin 12 14 3000)
    \n
    \"Fig.
    Fig. 3: Aproximaciones lineales de la sucesi\u00f3n de Ulam<\/figcaption><\/figure><\/p>\n
  •  Figura 4: Densidad de la sucesi\u00f3n de Ulam calculada con
    \n(dibujoDensidadU 1 3000)
    \n
    \"Fig.
    Fig. 4: Densidad de la sucesi\u00f3n de Ulam<\/figcaption><\/figure>\n<\/ul>\n","protected":false},"excerpt":{"rendered":"
    Los n\u00fameros de Ulam son los elementos de la sucesi\u00f3n u(n) definida por u(1) = 1, u(2) = 2 y, para n > 2, u(n) es el entero m\u00e1s peque\u00f1o que se puede escribir exactamente de una forma como suma de dos t\u00e9rminos anteriores diferentes entre s\u00ed. Seg\u00fan la definici\u00f3n, 3=1+2 es un n\u00famero de…<\/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":[5,1],"tags":[270],"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\/3496"}],"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=3496"}],"version-history":[{"count":21,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/3496\/revisions"}],"predecessor-version":[{"id":3555,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/3496\/revisions\/3555"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=3496"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=3496"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=3496"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}