{"id":7742,"date":"2022-05-21T08:28:17","date_gmt":"2022-05-21T06:28:17","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=7742"},"modified":"2022-05-21T08:28:17","modified_gmt":"2022-05-21T06:28:17","slug":"pfh-la-semana-en-exercitium-del-16-al-20-de-mayo-de-2022","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/pfh-la-semana-en-exercitium-del-16-al-20-de-mayo-de-2022\/","title":{"rendered":"PFH: La semana en Exercitium (del 16 al 20 de mayo de 2022)"},"content":{"rendered":"<p>Esta semana he publicado en <a href=\"http:\/\/bit.ly\/2sqPtGs\">Exercitium<\/a> las soluciones de los siguientes problemas:<\/p>\n<ul>\n<li><a href=\"#ej1\">1. Suma de divisores<\/a><\/li>\n<li><a href=\"#ej2\">2. Sucesi\u00f3n de sumas de dos n\u00fameros abundantes<\/a><\/li>\n<li><a href=\"#ej3\">3. Sumas de 4 primos<\/a><\/li>\n<li><a href=\"#ej4\">4. Parejas de n\u00fameros y divisores<\/a><\/li>\n<li><a href=\"#ej5\">5. Sumas de divisores propios<\/a><\/li>\n<\/ul>\n<p>A continuaci\u00f3n se muestran las soluciones.<br \/>\n<!--more--><br \/>\n<a name=\"ej1\"><\/a><\/p>\n<h3>1. Suma de divisores<\/h3>\n<p>Definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   sumaDivisores :: Integer -> Integer\n<\/pre>\n<p>tal que <code>(sumaDivisores x)<\/code> es la suma de los divisores de <code>x<\/code>. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   sumaDivisores 12  ==  28\n   sumaDivisores 25  ==  31\n   sumaDivisores (product [1..25])  ==  93383273455325195473152000\n   length (show (sumaDivisores (product [1..30000])))  ==  121289\n   maximum (map sumaDivisores [1..10^5])  ==  403200\n<\/pre>\n<p><!--more--><\/p>\n<h4>Soluciones<\/h4>\n<pre lang=\"haskell\">\nimport Data.List (genericLength, group, inits)\nimport Data.Numbers.Primes (primeFactors)\nimport Test.QuickCheck\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\nsumaDivisores1 :: Integer -> Integer\nsumaDivisores1 = sum . divisores\n\n-- (divisores x) es la lista de los divisores de x. Por ejemplo,\n--    divisores 60  ==  [1,5,3,15,2,10,6,30,4,20,12,60]\ndivisores :: Integer -> [Integer]\ndivisores = map (product . concat)\n          . productoCartesiano\n          . map inits\n          . group\n          . primeFactors\n\n-- (productoCartesiano xss) es el producto cartesiano de los conjuntos\n-- xss. Por ejemplo,\n--    \u03bb> producto [[1,3],[2,5],[6,4]]\n--    [[1,2,6],[1,2,4],[1,5,6],[1,5,4],[3,2,6],[3,2,4],[3,5,6],[3,5,4]]\nproductoCartesiano :: [[a]] -> [[a]]\nproductoCartesiano []       = [[]]\nproductoCartesiano (xs:xss) =\n  [x:ys | x <- xs, ys <- productoCartesiano xss]\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\nsumaDivisores2 :: Integer -> Integer\nsumaDivisores2 = sum\n               . map (product . concat)\n               . sequence\n               . map inits\n               . group\n               . primeFactors\n\n-- 3\u00aa soluci\u00f3n\n-- ===========\n\n-- Si la descomposici\u00f3n de x en factores primos es\n--    x = p(1)^e(1) . p(2)^e(2) . .... . p(n)^e(n)\n-- entonces la suma de los divisores de x es\n--    p(1)^(e(1)+1) - 1     p(2)^(e(2)+1) - 1       p(n)^(e(2)+1) - 1\n--   ------------------- . ------------------- ... -------------------\n--        p(1)-1                p(2)-1                  p(n)-1\n-- Ver la demostraci\u00f3n en http:\/\/bit.ly\/2zUXZPc\n\nsumaDivisores3 :: Integer -> Integer\nsumaDivisores3 x =\n  product [(p^(e+1)-1) `div` (p-1) | (p,e) <- factorizacion x]\n\n-- (factorizacion x) es la lista de las bases y exponentes de la\n-- descomposici\u00f3n prima de x. Por ejemplo,\n--    factorizacion 600  ==  [(2,3),(3,1),(5,2)]\nfactorizacion :: Integer -> [(Integer,Integer)]\nfactorizacion = map primeroYlongitud . group . primeFactors\n\n-- (primeroYlongitud xs) es el par formado por el primer elemento de xs\n-- y la longitud de xs. Por ejemplo,\n--    primeroYlongitud [3,2,5,7] == (3,4)\nprimeroYlongitud :: [a] -> (a,Integer)\nprimeroYlongitud (x:xs) =\n  (x, 1 + genericLength xs)\n\n-- Comprobaci\u00f3n de equivalencia\n-- ============================\n\n-- La propiedad es\nprop_sumaDivisores :: Positive Integer -> Bool\nprop_sumaDivisores (Positive x) =\n  all (== sumaDivisores1 x)\n      [ sumaDivisores2 x\n      , sumaDivisores3 x\n      ]\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck prop_sumaDivisores\n--    +++ OK, passed 100 tests.\n\n-- Comparaci\u00f3n de eficiencia\n-- =========================\n\n-- La comparaci\u00f3n es\n--   \u03bb> sumaDivisores1 251888923423315469521109880000000\n--   1471072204661054993275791673480320\n--   (10.63 secs, 10,614,618,080 bytes)\n--   \u03bb> sumaDivisores2 251888923423315469521109880000000\n--   1471072204661054993275791673480320\n--   (2.51 secs, 5,719,399,056 bytes)\n--   \u03bb> sumaDivisores3 251888923423315469521109880000000\n--   1471072204661054993275791673480320\n--   (0.01 secs, 177,480 bytes)\n<\/pre>\n<p>El c\u00f3digo se encuentra en <a href=\"https:\/\/github.com\/jaalonso\/Exercitium\/blob\/main\/src\/Suma_de_divisores.hs\">GitHub<\/a>.<\/p>\n<p><a name=\"ej2\"><\/a><\/p>\n<h3>2. Sucesi\u00f3n de sumas de dos n\u00fameros abundantes<\/h3>\n<p>Un n\u00famero <code>n<\/code> es <a href=\"http:\/\/bit.ly\/1vySpf2\">abundante<\/a> si la suma de los divisores propios de <code>n<\/code> es mayor que <code>n<\/code>. El primer n\u00famero abundante es el 12 (cuyos divisores propios son 1, 2, 3, 4 y 6 cuya suma es 16). Por tanto, el menor n\u00famero que es la suma de dos n\u00fameros abundantes es el 24.<\/p>\n<p>Definir la sucesi\u00f3n<\/p>\n<pre lang=\"text\">\n   sumasDeDosAbundantes :: [Integer]\n<\/pre>\n<p>cuyos elementos son los n\u00fameros que se pueden escribir como suma de dos n\u00fameros abundantes. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   take 10 sumasDeDosAbundantes  ==  [24,30,32,36,38,40,42,44,48,50]\n<\/pre>\n<p><!--more--><\/p>\n<h4>Soluciones<\/h4>\n<pre lang=\"haskell\">\nimport Data.List (genericLength, group)\nimport Data.Numbers.Primes (primeFactors)\nimport Test.QuickCheck\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\nsumasDeDosAbundantes1 :: [Integer]\nsumasDeDosAbundantes1 = [n | n <- [1..], esSumaDeDosAbundantes n]\n\n-- (esSumaDeDosAbundantes n) se verifica si n es suma de dos n\u00fameros\n-- abundantes. Por ejemplo,\n--    esSumaDeDosAbundantes 24           ==  True\n--    any esSumaDeDosAbundantes [1..22]  ==  False\nesSumaDeDosAbundantes :: Integer -> Bool\nesSumaDeDosAbundantes n = (not . null) [x | x <- xs, n-x `elem` xs]\n  where xs = takeWhile (<n) abundantes\n\n-- abundantes es la lista de los n\u00fameros abundantes. Por ejemplo,\n--    take 10 abundantes  ==  [12,18,20,24,30,36,40,42,48,54]\nabundantes :: [Integer]\nabundantes = [n | n <- [2..], abundante n]\n\n-- (abundante n) se verifica si n es abundante. Por ejemplo,\n--    abundante 12  ==  True\n--    abundante 11  ==  False\nabundante :: Integer -> Bool\nabundante n = sum (divisores n) > n\n\n-- (divisores n) es la lista de los divisores propios de n. Por ejemplo,\n--    divisores 12  ==  [1,2,3,4,6]\ndivisores :: Integer -> [Integer]\ndivisores n = [x | x <- [1..n `div` 2], n `mod` x == 0]\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\nsumasDeDosAbundantes2 :: [Integer]\nsumasDeDosAbundantes2 = filter esSumaDeDosAbundantes2 [1..]\n\nesSumaDeDosAbundantes2 :: Integer -> Bool\nesSumaDeDosAbundantes2 n = (not . null) [x | x <- xs, n-x `elem` xs]\n  where xs = takeWhile (<n) abundantes2\n\nabundantes2 :: [Integer]\nabundantes2 = filter abundante2 [2..]\n\nabundante2 :: Integer -> Bool\nabundante2 n = sumaDivisores n > n\n\nsumaDivisores :: Integer -> Integer\nsumaDivisores x =\n  product [(p^(e+1)-1) `div` (p-1) | (p,e) <- factorizacion x] - x\n\n-- (factorizacion x) es la lista de las bases y exponentes de la\n-- descomposici\u00f3n prima de x. Por ejemplo,\n--    factorizacion 600  ==  [(2,3),(3,1),(5,2)]\nfactorizacion :: Integer -> [(Integer,Integer)]\nfactorizacion = map primeroYlongitud . group . primeFactors\n\n-- (primeroYlongitud xs) es el par formado por el primer elemento de xs\n-- y la longitud de xs. Por ejemplo,\n--    primeroYlongitud [3,2,5,7] == (3,4)\nprimeroYlongitud :: [a] -> (a,Integer)\nprimeroYlongitud (x:xs) =\n  (x, 1 + genericLength xs)\n\n-- Comprobaci\u00f3n de equivalencia\n-- ============================\n\n-- La propiedad es\nprop_sumasDeDosAbundantes :: Positive Int -> Bool\nprop_sumasDeDosAbundantes (Positive n) =\n  sumasDeDosAbundantes1 !! n == sumasDeDosAbundantes2 !! n\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck prop_sumasDeDosAbundantes\n--    +++ OK, passed 100 tests.\n\n-- Comparaci\u00f3n de eficiencia\n-- =========================\n\n-- La comparaci\u00f3n es\n--    \u03bb> sumasDeDosAbundantes1 !! (2*10^3)\n--    2887\n--    (2.54 secs, 516,685,168 bytes)\n--    \u03bb> sumasDeDosAbundantes2 !! (2*10^3)\n--    2887\n--    (1.43 secs, 141,606,136 bytes)\n<\/pre>\n<p>El c\u00f3digo se encuentra en <a href=\"https:\/\/github.com\/jaalonso\/Exercitium\/blob\/main\/src\/Sumas_de_dos_abundantes.hs\">GitHub<\/a>.<\/p>\n<p><a name=\"ej3\"><\/a><\/p>\n<h3>3. Sumas de 4 primos<\/h3>\n<p>La <a href=\"http:\/\/bit.ly\/1L19MIT\">conjetura de Waring sobre los n\u00fameros primos<\/a> establece que todo n\u00famero impar es primo o la suma de tres primos. La <a href=\"http:\/\/bit.ly\/1enFuR8\">conjetura de Goldbach<\/a> afirma que todo  par mayor que 2 es la suma de dos n\u00fameros primos. Ambos  ha estado abiertos durante m\u00e1s de 200 a\u00f1os. En este problema no se propone su soluci\u00f3n, sino una tarea m\u00e1s simple: buscar una manera de expresar los enteros mayores que 7 como suma de exactamente cuatro n\u00fameros primos; es decir, definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   suma4primos :: Integer -> [(Integer,Integer,Integer,Integer)]\n<\/pre>\n<p>tal que <code>(suma4primos n)<\/code> es la lista de las cu\u00e1druplas crecientes <code>(a,b,c,d)<\/code> de n\u00fameros primos cuya suma es <code>n<\/code> (que se supone mayor que 7). Por ejemplo,<\/p>\n<pre lang=\"text\">\n   suma4primos 18             == [(2,2,3,11),(2,2,7,7),(3,3,5,7),(3,5,5,5)]\n   head (suma4primos (10^14)) == (2,2,23,99999999999973)\n<\/pre>\n<p>Comprobar con QuickCheck que todo entero mayor que 7 se puede escribir como suma de exactamente cuatro n\u00fameros primos.<\/p>\n<p><!--more--><\/p>\n<h4>Soluciones<\/h4>\n<pre lang=\"haskell\">\nimport Data.Numbers.Primes (isPrime, primes)\nimport Test.QuickCheck\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\nsuma4primos1 :: Integer -> [(Integer, Integer, Integer, Integer)]\nsuma4primos1 n =\n  [(a,b,c,d) | let as = takeWhile (< n) primes,\n               a <- as,\n               let bs = takeWhile (< n-a) as,\n               b <- bs, a <= b,\n               let cs = takeWhile (< n-a-b) bs,\n               c <- cs, b <= c,\n               let d = n-a-b-c, c <= d,\n               isPrime d]\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\nsuma4primos2 :: Integer -> [(Integer, Integer, Integer, Integer)]\nsuma4primos2 n =\n  [(a,b,c,d) | let as = takeWhile (< n) primes,\n               a <- as,\n               let bs = takeWhile (< n-a) (dropWhile (< a) as),\n               b <- bs,\n               let cs = takeWhile (<n-a-b) (dropWhile (< b) bs),\n               c <- cs,\n               let d = n-a-b-c,\n               c <= d,\n               isPrime d]\n\n-- Comprobaci\u00f3n de equivalencia\n-- ============================\n\n-- La propiedad es\nprop_suma4primos :: Positive Integer -> Bool\nprop_suma4primos (Positive n) =\n  suma4primos1 n == suma4primos2 n\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck prop_suma4primos\n--    +++ OK, passed 100 tests; 526 discarded.\n\n-- Comparaci\u00f3n de eficiencia\n-- =========================\n\n-- La comparaci\u00f3n es\n--    \u03bb> length (suma4primos1 2000)\n--    90219\n--    (2.98 secs, 4,517,620,744 bytes)\n--    \u03bb> length (suma4primos2 2000)\n--    90219\n--    (2.22 secs, 4,223,251,928 bytes)\n--\n--    \u03bb> head (suma4primos1 (10^14))\n--    (2,2,23,99999999999973)\n--    (1.67 secs, 5,963,327,168 bytes)\n--    \u03bb> head (suma4primos2 (10^14))\n--    (2,2,23,99999999999973)\n--    (1.70 secs, 5,963,326,848 bytes)\n\n-- Comprobaci\u00f3n de la propiedad\n-- ============================\n\n-- La propiedad es\nprop_suma4primos2 :: Integer -> Property\nprop_suma4primos2 n =\n  n > 7 ==> not (null (suma4primos1 n))\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck prop_suma4primos2\n--    +++ OK, passed 100 tests; 582 discarded.\n<\/pre>\n<p>El c\u00f3digo se encuentra en <a href=\"https:\/\/github.com\/jaalonso\/Exercitium\/blob\/main\/src\/Sumas_de_4_primos.hs\">GitHub<\/a>.<\/p>\n<p><a name=\"ej4\"><\/a><\/p>\n<h3>4. Parejas de n\u00fameros y divisores<\/h3>\n<p>Definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   divisoresHasta :: Int -> [(Int,Int)]\n<\/pre>\n<p>tal que <code>(divisoresHasta n)<\/code> es la lista de los pares <code>(a,b)<\/code> tales que <code>a<\/code> es un n\u00famero entre 2 y <code>n<\/code> y <code>b<\/code> es un divisor propio de <code>a<\/code>. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   \u03bb> divisoresHasta 6\n   [(2,1),(3,1),(4,1),(5,1),(6,1),(4,2),(6,2),(6,3)]\n   \u03bb> divisoresHasta 8\n   [(2,1),(3,1),(4,1),(5,1),(6,1),(7,1),(8,1),(4,2),(6,2),(8,2),(6,3),(8,4)]\n   \u03bb> length (divisoresHasta 1234567)\n   16272448\n<\/pre>\n<p><!--more--><\/p>\n<h4>Soluciones<\/h4>\n<pre lang=\"haskell\">\nimport Data.List (sort, sortBy)\nimport Data.Ord (comparing)\nimport Data.Tuple (swap)\nimport Test.QuickCheck\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\ndivisoresHasta1 :: Int -> [(Int,Int)]\ndivisoresHasta1 n =\n  ordena (concat [[(a,b) | b <- divisoresPropios a] | a <- [2..n]])\n  where ordena ps = [intercambia p | p <- sort (map intercambia ps)]\n        intercambia (x,y) = (y,x)\n\ndivisoresPropios :: Int -> [Int]\ndivisoresPropios n = [x | x <- [1..n `div` 2], n `mod` x == 0]\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\ndivisoresHasta2 :: Int -> [(Int,Int)]\ndivisoresHasta2 n =\n  ordena (concat [[(a,b) | b <- divisoresPropios a] | a <- [2..n]])\n  where ordena           = sortBy comp\n        comp (x,y) (u,v) = compare (y,x) (v,u)\n\n-- 3\u00aa soluci\u00f3n\n-- ===========\n\ndivisoresHasta3 :: Int -> [(Int,Int)]\ndivisoresHasta3 n =\n  ordena (concat [[(a,b) | b <- divisoresPropios a] | a <- [2..n]])\n  where ordena = sortBy (comparing swap)\n\n-- 4\u00aa soluci\u00f3n\n-- ===========\n\ndivisoresHasta4 :: Int -> [(Int,Int)]\ndivisoresHasta4 n =\n  [(a,b) | b <- [1..n `div` 2], a <- [2*b, 3*b..n]]\n\n-- Comprobaci\u00f3n de equivalencia\n-- ============================\n\n-- La propiedad es\nprop_divisoresHasta :: Positive Int -> Bool\nprop_divisoresHasta (Positive n) =\n  all (== divisoresHasta1 n)\n      [ divisoresHasta2 n\n      , divisoresHasta3 n\n      , divisoresHasta4 n\n      ]\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck prop_divisoresHasta\n--    +++ OK, passed 100 tests.\n\n-- Comparaci\u00f3n de eficiencia\n-- =========================\n\n-- La comparaci\u00f3n es\n--    \u03bb> length (divisoresHasta1 4000)\n--    29805\n--    (1.78 secs, 843,584,472 bytes)\n--    \u03bb> length (divisoresHasta2 4000)\n--    29805\n--    (1.78 secs, 879,421,056 bytes)\n--    \u03bb> length (divisoresHasta3 4000)\n--    29805\n--    (1.70 secs, 876,475,584 bytes)\n--    \u03bb> length (divisoresHasta4 4000)\n--    29805\n--    (0.02 secs, 6,332,016 bytes)\n<\/pre>\n<p>El c\u00f3digo se encuentra en <a href=\"https:\/\/github.com\/jaalonso\/Exercitium\/blob\/main\/src\/Parejas_de_numeros_y_divisores.hs\">GitHub<\/a>.<\/p>\n<p><a name=\"ej5\"><\/a><\/p>\n<h3>5. Sumas de divisores propios<\/h3>\n<p>Definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   sumaDivisoresHasta :: Integer -> [(Integer,Integer)]\n<\/pre>\n<p>tal que <code>(sumaDivisoresHasta n)<\/code> es la lista de los pares <code>(a,b)<\/code> tales que <code>a<\/code> es un n\u00famero entre 1 y <code>n<\/code> y <code>b<\/code> es la suma de los divisores propios de <code>a<\/code>. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   \u03bb> sumaDivisoresHasta 12\n   [(1,0),(2,1),(3,1),(4,3),(5,1),(6,6),(7,1),(8,7),(9,4),(10,8),(11,1),(12,16)]\n   \u03bb> last (sumaDivisoresHasta2 (10^7))\n   (10000000,14902280)\n<\/pre>\n<p><!--more--><\/p>\n<h4>Soluciones<\/h4>\n<pre lang=\"haskell\">\nimport Data.Array (accumArray, assocs)\nimport Data.List (genericLength, group)\nimport Data.Numbers.Primes (primeFactors)\nimport Test.QuickCheck\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\nsumaDivisoresHasta1 :: Integer -> [(Integer,Integer)]\nsumaDivisoresHasta1 n = [(x, sum (divisores x)) | x <- [1..n]]\n\ndivisores :: Integer -> [Integer]\ndivisores n = [x | x <- [1..n `div` 2], n `mod` x == 0]\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\nsumaDivisoresHasta2 :: Integer -> [(Integer,Integer)]\nsumaDivisoresHasta2 n = [(x, sumaDivisores x) | x <- [1..n]]\n\nsumaDivisores :: Integer -> Integer\nsumaDivisores x =\n  product [(p^(e+1)-1) `div` (p-1) | (p,e) <- factorizacion x] - x\n\n-- (factorizacion x) es la lista de las bases y exponentes de la\n-- descomposici\u00f3n prima de x. Por ejemplo,\n--    factorizacion 600  ==  [(2,3),(3,1),(5,2)]\nfactorizacion :: Integer -> [(Integer,Integer)]\nfactorizacion = map primeroYlongitud . group . primeFactors\n\n-- (primeroYlongitud xs) es el par formado por el primer elemento de xs\n-- y la longitud de xs. Por ejemplo,\n--    primeroYlongitud [3,2,5,7] == (3,4)\nprimeroYlongitud :: [a] -> (a,Integer)\nprimeroYlongitud (x:xs) =\n  (x, 1 + genericLength xs)\n\n-- 3\u00aa soluci\u00f3n\n-- ===========\n\nsumaDivisoresHasta3 :: Integer -> [(Integer,Integer)]\nsumaDivisoresHasta3 n = assocs (accumArray (+) 0 (1,n) (divisoresHasta n))\n\n-- (divisoresHasta n) es la lista de los pares (a,b) tales que a es\n-- un n\u00famero entre 2 y n y b es un divisor propio e x. Por ejemplo,\n--    \u03bb> divisoresHasta 6\n--    [(2,1),(3,1),(4,1),(5,1),(6,1),(4,2),(6,2),(6,3)]\n--    \u03bb> divisoresHasta 8\n--    [(2,1),(3,1),(4,1),(5,1),(6,1),(7,1),(8,1),(4,2),(6,2),(8,2),(6,3),(8,4)]\ndivisoresHasta :: Integer -> [(Integer,Integer)]\ndivisoresHasta n = [(a,b) | b <- [1..n `div` 2], a <- [b*2, b*3..n]]\n\n-- Comprobaci\u00f3n de equivalencia\n-- ============================\n\n-- La propiedad es\nprop_sumaDivisoresHasta :: Positive Integer -> Bool\nprop_sumaDivisoresHasta (Positive n) =\n  all (== sumaDivisoresHasta1 n)\n      [ sumaDivisoresHasta2 n\n      , sumaDivisoresHasta3 n\n      ]\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck prop_sumaDivisoresHasta\n--    +++ OK, passed 100 tests.\n\n-- Comparaci\u00f3n de eficiencia\n-- =========================\n\n-- La comparaci\u00f3n es\n--    \u03bb> last (sumaDivisoresHasta1 (10^6))\n--    (1000000,1480437)\n--    (0.47 secs, 308,542,392 bytes)\n--    \u03bb> last (sumaDivisoresHasta2 (10^6))\n--    (1000000,2480437)\n--    (0.26 secs, 208,548,944 bytes)\n--    \u03bb> last (sumaDivisoresHasta3 (10^6))\n--    (1000000,1480437)\n--    (6.65 secs, 3,249,831,856 bytes)\n--\n--    \u03bb> last (sumaDivisoresHasta1 (5*10^6))\n--    (5000000,7402312)\n--    (2.27 secs, 1,540,543,352 bytes)\n--    \u03bb> last (sumaDivisoresHasta2 (5*10^6))\n--    (5000000,12402312)\n--    (1.19 secs, 1,040,549,800 bytes)\n<\/pre>\n<p>El c\u00f3digo se encuentra en <a href=\"https:\/\/github.com\/jaalonso\/Exercitium\/blob\/main\/src\/Sumas_de_divisores_propios.hs\">GitHub<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Esta semana he publicado en Exercitium las soluciones de los siguientes problemas: 1. Suma de divisores 2. Sucesi\u00f3n de sumas de dos n\u00fameros abundantes 3. Sumas de 4 primos 4. Parejas de n\u00fameros y divisores 5. Sumas de divisores propios A continuaci\u00f3n se muestran las soluciones.<\/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":[337],"tags":[],"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\/7742"}],"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=7742"}],"version-history":[{"count":1,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/7742\/revisions"}],"predecessor-version":[{"id":7743,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/7742\/revisions\/7743"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=7742"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=7742"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=7742"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}