Definir la función
esPotenciaDeDos :: Integer -> Bool |
tal que (esPotenciaDeDos n) se verifica si n es una potencia de dos (suponiendo que n es mayor que 0). Por ejemplo.
esPotenciaDeDos 1 == True esPotenciaDeDos 2 == True esPotenciaDeDos 6 == False esPotenciaDeDos 8 == True esPotenciaDeDos 1024 == True esPotenciaDeDos 1026 == False esPotenciaDeDos (2^(10^8)) == True |
Los primeros números de Fibonacci son
1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, ... |
tales que los dos primeros son iguales a 1 y los siguientes se obtienen sumando los dos anteriores.
El teorema de Zeckendorf establece que todo entero positivo n se puede representar, de manera única, como la suma de números de Fibonacci no consecutivos decrecientes. Dicha suma se llama la representación de Zeckendorf de n. Por ejemplo, la representación de Zeckendorf de 100 es
100 = 89 + 8 + 3 |
Hay otras formas de representar 100 como sumas de números de Fibonacci; por ejemplo,
100 = 89 + 8 + 2 + 1 100 = 55 + 34 + 8 + 3 |
pero no son representaciones de Zeckendorf porque 1 y 2 son números de Fibonacci consecutivos, al igual que 34 y 55.
Definir la función
zeckendorf :: Integer -> [Integer] |
tal que (zeckendorf n) es la representación de Zeckendorf de n. Por ejemplo,
zeckendorf 100 == [89,8,3] zeckendorf 200 == [144,55,1] zeckendorf 300 == [233,55,8,3,1] length (zeckendorf (10^50000)) == 66097 |
Definir la función
eliminaAisladas :: Eq a => a -> [a] -> [a] |
tal que (eliminaAisladas x ys) es la lista obtenida eliminando en ys las ocurrencias aisladas de x (es decir, aquellas ocurrencias de x tales que su elemento anterior y posterior son distintos de x). Por ejemplo,
eliminaAisladas 'X' "" == "" eliminaAisladas 'X' "X" == "" eliminaAisladas 'X' "XX" == "XX" eliminaAisladas 'X' "XXX" == "XXX" eliminaAisladas 'X' "abcd" == "abcd" eliminaAisladas 'X' "Xabcd" == "abcd" eliminaAisladas 'X' "XXabcd" == "XXabcd" eliminaAisladas 'X' "XXXabcd" == "XXXabcd" eliminaAisladas 'X' "abcdX" == "abcd" eliminaAisladas 'X' "abcdXX" == "abcdXX" eliminaAisladas 'X' "abcdXXX" == "abcdXXX" eliminaAisladas 'X' "abXcd" == "abcd" eliminaAisladas 'X' "abXXcd" == "abXXcd" eliminaAisladas 'X' "abXXXcd" == "abXXXcd" eliminaAisladas 'X' "XabXcdX" == "abcd" eliminaAisladas 'X' "XXabXXcdXX" == "XXabXXcdXX" eliminaAisladas 'X' "XXXabXXXcdXXX" == "XXXabXXXcdXXX" eliminaAisladas 'X' "XabXXcdXeXXXfXx" == "abXXcdeXXXfx" |
La sucesión de Loomis generada por un número entero positivo x es la sucesión cuyos términos se definen por
Los primeros términos de las primeras sucesiones de Loomis son
Se observa que a partir de un término todas coinciden con la generada por 1. Dicho término se llama el punto de convergencia. Por ejemplo,
Definir las siguientes funciones
sucLoomis :: Integer -> [Integer] convergencia :: Integer -> Integer graficaConvergencia :: [Integer] -> IO () |
tales que
λ> take 15 (sucLoomis 1)
[1,2,4,8,16,22,26,38,62,74,102,104,108,116,122]
λ> take 15 (sucLoomis 2)
[2,4,8,16,22,26,38,62,74,102,104,108,116,122,126]
λ> take 15 (sucLoomis 3)
[3,6,12,14,18,26,38,62,74,102,104,108,116,122,126]
λ> take 15 (sucLoomis 4)
[4,8,16,22,26,38,62,74,102,104,108,116,122,126,138]
λ> take 15 (sucLoomis 5)
[5,10,11,12,14,18,26,38,62,74,102,104,108,116,122]
λ> take 15 (sucLoomis 20)
[20,22,26,38,62,74,102,104,108,116,122,126,138,162,174]
λ> take 15 (sucLoomis 100)
[100,101,102,104,108,116,122,126,138,162,174,202,206,218,234]
λ> sucLoomis 1 !! (2*10^5)
235180736652 |
convergencia 2 == 2
convergencia 3 == 26
convergencia 4 == 4
convergencia 17 == 38
convergencia 19 == 102
convergencia 43 == 162
convergencia 27 == 202
convergencia 58 == 474
convergencia 63 == 150056
convergencia 81 == 150056
convergencia 89 == 150056
convergencia (10^12) == 1000101125092 |
import Data.List ((\\)) import Data.Char (digitToInt) import Graphics.Gnuplot.Simple (plotList, Attribute (Key, Title, XRange, PNG)) -- 1ª definición de sucLoomis -- ========================== sucLoomis :: Integer -> [Integer] sucLoomis x = map (loomis x) [0..] loomis :: Integer -> Integer -> Integer loomis x 0 = x loomis x n = y + productoDigitosNoNulos y where y = loomis x (n-1) productoDigitosNoNulos :: Integer -> Integer productoDigitosNoNulos = product . digitosNoNulos digitosNoNulos :: Integer -> [Integer] digitosNoNulos x = [read [c] | c <- show x, c /= '0'] -- 2ª definición de sucLoomis -- ========================== sucLoomis2 :: Integer -> [Integer] sucLoomis2 = iterate siguienteLoomis siguienteLoomis :: Integer -> Integer siguienteLoomis y = y + productoDigitosNoNulos y -- 3ª definición de sucLoomis -- ========================== sucLoomis3 :: Integer -> [Integer] sucLoomis3 = iterate ((+) <*> product . map (toInteger . digitToInt) . filter (/= '0') . show) -- Comparación de eficiencia -- ========================= -- λ> sucLoomis 1 !! 30000 -- 6571272766 -- (2.45 secs, 987,955,944 bytes) -- λ> sucLoomis2 1 !! 30000 -- 6571272766 -- (2.26 secs, 979,543,328 bytes) -- λ> sucLoomis3 1 !! 30000 -- 6571272766 -- (0.31 secs, 88,323,832 bytes) -- 1ª definición de convergencia -- ============================= convergencia1 :: Integer -> Integer convergencia1 x = head (dropWhile noEnSucLoomisDe1 (sucLoomis x)) noEnSucLoomisDe1 :: Integer -> Bool noEnSucLoomisDe1 x = not (pertenece x sucLoomisDe1) sucLoomisDe1 :: [Integer] sucLoomisDe1 = sucLoomis 1 pertenece :: Integer -> [Integer] -> Bool pertenece x ys = x == head (dropWhile (<x) ys) -- 2ª definición de convergencia -- ============================= convergencia2 :: Integer -> Integer convergencia2 = aux (sucLoomis3 1) . sucLoomis3 where aux as@(x:xs) bs@(y:ys) | x == y = x | x < y = aux xs bs | otherwise = aux as ys -- 3ª definición de convergencia -- ============================= convergencia3 :: Integer -> Integer convergencia3 = head . interseccion (sucLoomis3 1) . sucLoomis3 -- (interseccion xs ys) es la intersección entre las listas ordenadas xs -- e ys. Por ejemplo, -- λ> take 10 (interseccion (sucLoomis3 1) (sucLoomis3 2)) -- [2,4,8,16,22,26,38,62,74,102] interseccion :: Ord a => [a] -> [a] -> [a] interseccion = aux where aux as@(x:xs) bs@(y:ys) = case compare x y of LT -> aux xs bs EQ -> x : aux xs ys GT -> aux as ys aux _ _ = [] -- 4ª definición de convergencia -- ============================= convergencia4 :: Integer -> Integer convergencia4 x = perteneceA (sucLoomis3 x) 1 where perteneceA (y:ys) n | y == c = y | otherwise = perteneceA ys c where c = head $ dropWhile (< y) $ sucLoomis3 n -- Comparación de eficiencia -- ========================= -- λ> convergencia1 (10^4) -- 150056 -- (2.94 secs, 1,260,809,808 bytes) -- λ> convergencia2 (10^4) -- 150056 -- (0.03 secs, 700,240 bytes) -- λ> convergencia3 (10^4) -- 150056 -- (0.03 secs, 1,165,496 bytes) -- λ> convergencia4 (10^4) -- 150056 -- (0.02 secs, 1,119,648 bytes) -- -- λ> convergencia2 (10^12) -- 1000101125092 -- (1.81 secs, 714,901,080 bytes) -- λ> convergencia3 (10^12) -- 1000101125092 -- (1.92 secs, 744,932,184 bytes) -- λ> convergencia4 (10^12) -- 1000101125092 -- (1.82 secs, 941,053,328 bytes) -- Definición de graficaConvergencia -- ================================== graficaConvergencia :: [Integer] -> IO () graficaConvergencia xs = plotList [ Key Nothing , Title "Convergencia de sucesiones de Loomis" , XRange (fromIntegral (minimum xs),fromIntegral (maximum xs)) , PNG "Las_sucesiones_de_Loomis_2.png" ] [(x,convergencia2 x) | x <- xs] |
Un conjunto de primos emparejables es un conjunto S de números primos tales que al concatenar cualquier par de elementos de S se obtiene un número primo. Por ejemplo, {3, 7, 109, 673} es un conjunto de primos emparejables ya que sus elementos son primos y las concatenaciones de sus parejas son 37, 3109, 3673, 73, 7109, 7673, 1093, 1097, 109673, 6733, 6737 y 673109 son primos.
Definir la función
emparejables :: Integer -> Integer -> [[Integer]] |
tal que (emparejables n m) es el conjunto de los conjuntos emparejables de n elementos menores que n. Por ejemplo,
take 5 (emparejables 2 10) == [[3,7]] take 5 (emparejables 3 10) == [] take 5 (emparejables 2 100) == [[3,7],[3,11],[3,17],[3,31],[3,37]] take 5 (emparejables 3 100) == [[3,37,67],[7,19,97]] take 5 (emparejables 4 100) == [] take 5 (emparejables 4 1000) == [[3,7,109,673],[23,311,677,827]] |
Los números de Fibonacci son los números F(n) de la siguiente sucesión
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, ... |
que comienza con 0 y 1 y los siguientes términos son las sumas de los dos anteriores.
Un número x es el producto de dos números de Fibonacci consecutivos si existe un n tal que
F(n) * F(n+1) = x |
y su prueba es (F(n),F(n+1),True). Por ejemplo, 714 es el producto de dos números de Fibonacci consecutivos ya que
F(8) = 21, F(9) = 34 y 714 = 21 * 34. |
Su prueba es (21, 34, True).
Un número x no es el producto de dos números de Fibonacci consecutivos si no existe un n tal que
F(n) * F(n+1) = x |
y su prueba es (F(m),F(m+1),False) donde m es el menor número tal que
F(m) * F(m+1) > x |
Por ejemplo, 800 no es el producto de dos números de Fibonacci consecutivos, ya que
F(8) = 21, F(9) = 34, F(10) = 55 y 21 * 34 < 800 < 34 * 55. |
Su prueba es (34, 55, False),
Definir la función
productoFib :: Integer -> (Integer, Integer, Bool) |
tal que (productoFib x) es la prueba de que es, o no es, el producto de dos números de Fibonacci consecutivos. Por ejemplo,
productoFib 714 == (21, 34, True) productoFib 800 == (34, 55, False) productoFib 4895 == (55, 89, True) productoFib 5895 == (89, 144, False) |
-- 1ª solución -- =========== productoFib :: Integer -> (Integer, Integer, Bool) productoFib n | c == n = (a,b,True) | otherwise = (a,b,False) where (a,b,c) = head (dropWhile (\(x,y,z) -> z < n) productos) -- fibs es la sucesión de números de Fibonacci. Por ejemplo, -- take 14 fibs == [0,1,1,2,3,5,8,13,21,34,55,89,144,233] fibs :: [Integer] fibs = 0 : 1 : zipWith (+) fibs (tail fibs) -- productos es la lista de las ternas (a,b,c) tales que a y b son dos -- números de Fibonacci consecutivos y c es su producto. Por ejemplo, -- λ> take 7 productos -- [(0,1,0),(1,1,1),(1,2,2),(2,3,6),(3,5,15),(5,8,40),(8,13,104)] productos :: [(Integer,Integer,Integer)] productos = [(x,y,x*y) | (x,y) <- zip fibs (tail fibs)] -- 2ª solución -- =========== productoFib2 :: Integer -> (Integer, Integer, Bool) productoFib2 n = aux 0 1 n where aux a b c | a * b >= c = (a, b, a * b == c) | otherwise = aux b (a + b) c -- 3ª solución -- =========== productoFib3 :: Integer -> (Integer, Integer, Bool) productoFib3 x = aux 0 1 where aux a b | a * b >= x = (a, b, x == a * b) | otherwise = aux b (a + b) -- Comparación de eficiencia -- ========================= -- La comparación es -- λ> let (x,_,_) = productoFib (10^20000) in length (show x) -- 10000 -- (1.15 secs, 323,396,360 bytes) -- λ> let (x,_,_) = productoFib2 (10^20000) in length (show x) -- 10000 -- (1.10 secs, 317,268,672 bytes) -- λ> let (x,_,_) = productoFib3 (10^20000) in length (show x) -- 10000 -- (1.08 secs, 314,972,440 bytes) |
“El placer que obtenemos de la música proviene de contar, pero contando inconscientemente. La música no es más que aritmética inconsciente.”
¡El mundo está en cuarentena! Hay una nueva pandemia que lucha contra la humanidad. Cada continente está aislado de los demás, pero las personas infectadas se han propagado antes de la advertencia.
En este problema se representará el mundo por una cadena como la siguiente
"01000000X000X011X0X" |
donde 0 representa no infectado, 1 representa infectado y X representa un océano
Las reglas de propagación son:
El problema consiste en encontrar el porcentaje de la población humana que se infectó al final. Por ejemplo,
inicio: "01000000X000X011X0X" final: "11111111X000X111X0X" total: 15 infectados: 11 porcentaje: 100*11/15 = 73.33333333333333 |
Definir la función
porcentajeInfectados :: String -> Double |
tal que (porcentajeInfectados xs) es el porcentaje final de infectados para el mapa inicial xs. Por ejemplo,
porcentajeInfectados "01000000X000X011X0X" == 73.33333333333333 porcentajeInfectados "01X000X010X011XX" == 72.72727272727273 porcentajeInfectados "XXXXX" == 0.0 porcentajeInfectados "0000000010" == 100.0 porcentajeInfectados "X00X000000X10X0100" == 42.857142857142854 |
import Data.List (genericLength) import Data.List.Split (splitOn) -- 1ª solución -- =========== porcentajeInfectados :: String -> Double porcentajeInfectados xs | nh == 0 = 0 | otherwise = 100 * ni / nh where ni = fromIntegral (numeroInfectados xs) nh = fromIntegral (numeroHabitantes xs) -- (continentes xs) es la lista de las poblaciones de los continentes -- del mapa xs. Por ejemplo, -- continentes "01000000X000X011X0X" == ["01000000","000","011","0"] -- continentes "01X000X010X011XX" == ["01","000","010","011"] -- continentes "XXXXX" == [""] -- continentes "0000000010" == ["0000000010"] -- continentes "X00X000000X10X0100" == ["","00","000000","10","0100"] continentes :: String -> [String] continentes [] = [] continentes xs = as : continentes (dropWhile (=='X') bs) where (as,bs) = break (=='X') xs -- (numeroInfectados xs) es el número final de infectados a partir del -- mapa xs. Por ejemplo, -- numeroInfectados "01000000X000X011X0X" == 11 numeroInfectados :: String -> Int numeroInfectados xs = sum [length ys | ys <- continentes xs , '1' `elem` ys] -- (numeroHabitantes xs) es el número final de habitantes del mapa -- xs. Por ejemplo, -- numeroHabitantes "01000000X000X011X0X" == 15 numeroHabitantes :: String -> Int numeroHabitantes xs = length (filter (/='X') xs) -- 2ª solución -- =========== porcentajeInfectados2 :: String -> Double porcentajeInfectados2 xs | nh == 0 = 0 | otherwise = 100 * ni / nh where ni = sum [genericLength ys | ys <- splitOn "X" xs, '1' `elem` ys] nh = genericLength (filter (/='X') xs) |
“El avance de las matemáticas puede ser visto como un progreso de lo infinito a lo finito.”
Goldbach, el de la famosa conjetura, hizo por lo menos otra conjetura que finalmente resultó ser falsa.
Esta última decía que todo número compuesto impar puede expresarse como la suma de un número primo más dos veces la suma de un cuadrado. Así por ejemplo,
9 = 7 + 2×1^2 15 = 7 + 2×2^2 21 = 3 + 2×3^2 25 = 7 + 2×3^2 27 = 19 + 2×2^2 33 = 31 + 2×1^2 |
Definir las sucesiones
imparesCompuestos :: [Integer] descomposiciones :: Integer -> [(Integer,Integer)] contraejemplosGoldbach :: [Integer] |
tales que
take 9 imparesCompuestos == [9,15,21,25,27,33,35,39,45] |
descomposiciones 9 == [(7,1)]
descomposiciones 21 == [(3,9),(13,4),(19,1)]
descomposiciones 5777 == [] |
Las 3 descomposiciones de 21 son
21 = 3 + 2*9 = 21 + 2*3^2
21 = 13 + 2*4 = 13 + 2*3^2
21 = 19 + 2*1 = 19 + 2*1^2 |
take 2 contraejemplosGoldbach == [5777,5993] |
Comprobar con QuickCheck que la conjetura de Golbach se verifica a partir de 5993; es decir, todo número compuesto impar mayor que 5993 puede expresarse como la suma de un número primo más dos veces la suma de un cuadrado.
Nota: Basado en el artículo La menos conocida de las conjeturas de Goldbach de Claudio Meller en el blog Números y algo más.
import Data.Numbers.Primes import Test.QuickCheck imparesCompuestos :: [Integer] imparesCompuestos = filter esCompuesto [3,5..] -- (esCompuesto x) se verifica si x es un número compuesto. Por ejemplo, -- esCompuesto 6 == True -- esCompuesto 7 == False esCompuesto :: Integer -> Bool esCompuesto = not . isPrime contraejemplosGoldbach :: [Integer] contraejemplosGoldbach = filter esContraejemplo imparesCompuestos -- (esContraejemplo x) es verifica si el número impar compuesto x es un -- contraejemplo de la conjetura de Goldbach. Por ejemplo, -- esContraejemplo 5777 == True -- esContraejemplo 15 == False esContraejemplo :: Integer -> Bool esContraejemplo = null . descomposiciones descomposiciones :: Integer -> [(Integer,Integer)] descomposiciones n = [(p,x) | p <- takeWhile (<=n) primes , (n - p) `mod` 2 == 0 , let x = (n - p) `div` 2 , esCuadrado x] -- (esCuadrado x) es verifica si x es un cuadrado perfecto. Por ejemplo, -- esCuadrado 16 == True -- esCuadrado 27 == False esCuadrado :: Integer -> Bool esCuadrado x = y^2 == x where y = ceiling (sqrt (fromIntegral x)) -- La propiedad es prop_conjetura :: Int -> Property prop_conjetura n = n >= 0 ==> not (esContraejemplo (imparesCompuestosMayore5993 !! n)) where imparesCompuestosMayore5993 = dropWhile (<=5993) imparesCompuestos -- La comprobación es -- λ> quickCheck prop_conjetura -- +++ OK, passed 100 tests. |
“Obvio es la palabra más peligrosa de las matemáticas.”
El teorema de la amistad afirma que
En cualquier reunión de n personas hay al menos dos personas que tienen el mismo número de amigos (suponiendo que la relación de amistad es simétrica).
Se pueden usar las siguientes representaciones:
Por ejemplo, [(2,3),(3,5)] representa una reunión de tres personas
(2, 3 y 5) donde
Definir la función
clasesAmigos :: [(Int,Int)] -> [[Int]] |
tal que (clasesAmigos r) es la clasificación según el número de amigos de las personas de la reunión r; es decir, la lista cuyos elementos son las listas de personas con 1 amigo, con 2 amigos y así hasta que se completa todas las personas de la reunión r. Por ejemplo,
clasesAmigos [(2,3),(3,5)] == [[2,5],[3]] clasesAmigos [(2,3),(4,5)] == [[2,3,4,5]] clasesAmigos [(2,3),(2,5),(3,5)] == [[2,3,5]] clasesAmigos [(2,3),(3,4),(2,5)] == [[4,5],[2,3]] clasesAmigos [(x,x+1) | x <- [1..5]] == [[1,6],[2,3,4,5]] length (clasesAmigos [(x,x+1) | x <- [1..2020]]) == 2 |
Comprobar con QuickCheck el teorema de la amistad; es decir, si r es una lista de pares de enteros, entonces (clasesAmigos r’) donde r’ es la lista de los pares (x,y) de r con x < y y se supone que r’ es no vacía.
import Data.List (nub, sort) import Test.QuickCheck -- 1ª solución -- =========== clasesAmigos :: [(Int,Int)] -> [[Int]] clasesAmigos ps = filter (not . null) [[x | x <- xs, numeroDeAmigos ps x == n] | n <- [1..length xs]] where xs = personas ps -- (personas ps) es la lista de personas en la reunión ps. Por ejemplo, -- personas [(2,3),(3,5)] == [2,3,5] personas :: [(Int,Int)] -> [Int] personas ps = sort (nub (map fst ps ++ map snd ps)) -- (numeroDeAmigos ps x) es el número de amigos de x en la reunión -- ps. Por ejemplo, -- numeroDeAmigos [(2,3),(3,5)] 2 == 1 -- numeroDeAmigos [(2,3),(3,5)] 3 == 2 -- numeroDeAmigos [(2,3),(3,5)] 5 == 1 numeroDeAmigos :: [(Int,Int)] -> Int -> Int numeroDeAmigos ps x = length (amigos ps x) -- (amigos ps x) es la lista de los amigos de x en la reunión ps. Por -- ejemplo, -- amigos [(2,3),(3,5)] 2 == [3] -- amigos [(2,3),(3,5)] 3 == [5,2] -- amigos [(2,3),(3,5)] 5 == [3] amigos :: [(Int,Int)] -> Int -> [Int] amigos ps x = nub ([b | (a,b) <- ps, a == x] ++ [a | (a,b) <- ps, b == x]) -- 2ª solución -- =========== clasesAmigos2 :: [(Int,Int)] -> [[Int]] clasesAmigos2 = clases . sort . tablaAmigos where clases [] = [] clases ps@((x,y):ps') = (map snd (takeWhile (\(a,b) -> a == x) ps)) : clases (dropWhile (\(a,b) -> a == x) ps') -- (tablaAmigos ps) es la lista de pares (a,b) tales que b es una -- persona de la reunión ps y a es su número de amigos. Por ejemplo, -- tablaAmigos [(2,3),(3,5)] == [(1,2),(2,3),(1,5)] tablaAmigos :: [(Int,Int)] -> [(Int,Int)] tablaAmigos ps = [(numeroDeAmigos ps x,x) | x <- personas ps] -- Equivalencia de las definiciones -- ================================ -- La propiedad es prop_equivalencia :: [(Int,Int)] -> Property prop_equivalencia ps = not (null ps') ==> clasesAmigos ps' == clasesAmigos2 ps' where ps' = [(x,y) | (x,y) <- ps, x < y] -- La comprobación es -- λ> quickCheck prop_equivalencia -- +++ OK, passed 100 tests. -- (1.06 secs, 337,106,752 bytes) -- Comparación de eficiencia -- ========================= -- λ> length (clasesAmigos [(x,x+1) | x <- [1..200]]) -- 2 -- (2.37 secs, 804,402,848 bytes) -- λ> length (clasesAmigos2 [(x,x+1) | x <- [1..200]]) -- 2 -- (0.02 secs, 4,287,256 bytes) -- El teorema de la amistad -- ======================== -- La propiedad es teoremaDeLaAmistad :: [(Int,Int)] -> Property teoremaDeLaAmistad ps = not (null ps') ==> not (null [xs | xs <- clasesAmigos2 ps', length xs > 1]) where ps' = [(x,y) | (x,y) <- ps, x < y] -- La comprobación es -- λ> quickCheck teoremaDeLaAmistad -- +++ OK, passed 100 tests. |
Me dijo el agua clara que reía,
bajo el sol, sobre el mármol de la fuente:
si te inquieta el enigma del presente
aprende el son de la salmodia mía.Antonio Machado
El postulado de Bertrand afirma que para cualquier número entero n > 1, existe al menos un número primo p con n < p < 2n.
Definir la función
siguientePrimo :: Integer -> Integer |
tal que (siguientePrimo n) es el menor primo mayor que n. Por ejemplo,
siguientePrimo 8 == 11 siguientePrimo 11 == 13 |
Comprobar con QuickCheck el postulado de Bertrand; es decir, para todo entero n > 1, se verifica que n < p < 2n, donde p es (siguientePrimo n).
import Data.Numbers.Primes import Test.QuickCheck siguientePrimo :: Integer -> Integer siguientePrimo n = head (dropWhile (<= n) primes) -- La propiedad es postuladoDeBertrand :: Integer -> Property postuladoDeBertrand n = n > 1 ==> n < p && p < 2 * n where p = siguientePrimo n -- La comprobación es -- λ> quickCheck postuladoDeBertrand -- +++ OK, passed 100 tests. |
Pero caer de cabeza,
en esta noche sin luna,
en medio de esta maleza,
junto a la negra laguna.Antonio Machado
José A. Alonso