Números primos sumas de dos primos

PorJosé A. Alonso 26-noviembre-201819-enero-2019

Definir las funciones

   esPrimoSumaDeDosPrimos :: Integer -> Bool

1	esPrimoSumaDeDosPrimos :: Integer -> Bool

primosSumaDeDosPrimos :: [Integer]
tales que

(esPrimoSumaDeDosPrimos x) se verifica si x es un número primo que se puede escribir como la suma de dos números primos. Por ejemplo,

     esPrimoSumaDeDosPrimos 19        ==  True
     esPrimoSumaDeDosPrimos 20        ==  False
     esPrimoSumaDeDosPrimos 23        ==  False
     esPrimoSumaDeDosPrimos 18409541  ==  False

1

2

3

4

esPrimoSumaDeDosPrimos 19 == True

esPrimoSumaDeDosPrimos 20 == False

esPrimoSumaDeDosPrimos 23 == False

esPrimoSumaDeDosPrimos 18409541 == False

primosSumaDeDosPrimos es la lista de los números primos que se pueden escribir como la suma de dos números primos. Por ejemplo,

     λ> take 17 primosSumaDeDosPrimos
     [5,7,13,19,31,43,61,73,103,109,139,151,181,193,199,229,241]
     λ> primosSumaDeDosPrimos !! (10^5)
     18409543

1

2

3

4

λ> take 17 primosSumaDeDosPrimos

[5,7,13,19,31,43,61,73,103,109,139,151,181,193,199,229,241]

λ> primosSumaDeDosPrimos !! (10^5)

18409543

Soluciones

import Data.Numbers.Primes (isPrime, primes)

-- 1ª solución
-- ===========

esPrimoSumaDeDosPrimos :: Integer -> Bool
esPrimoSumaDeDosPrimos x =
  isPrime x && isPrime (x - 2)

primosSumaDeDosPrimos :: [Integer]
primosSumaDeDosPrimos =
  [x | x <- primes
     , isPrime (x - 2)]

-- 2ª solución
-- ===========

primosSumaDeDosPrimos2 :: [Integer]
primosSumaDeDosPrimos2 =
  [y | (x,y) <- zip primes (tail primes)
     , y == x + 2]

esPrimoSumaDeDosPrimos2 :: Integer -> Bool
esPrimoSumaDeDosPrimos2 x = 
  x == head (dropWhile (<x) primosSumaDeDosPrimos2)

-- Equivalencias
-- =============

-- Equivalencia de esPrimoSumaDeDosPrimos
prop_esPrimoSumaDeDosPrimos_equiv :: Integer -> Property
prop_esPrimoSumaDeDosPrimos_equiv x =
  x > 0 ==>
  esPrimoSumaDeDosPrimos x == esPrimoSumaDeDosPrimos2 x

-- La comprobación es
--    λ> quickCheck prop_esPrimoSumaDeDosPrimos_equiv
--    +++ OK, passed 100 tests.

-- Equivalencia de primosSumaDeDosPrimos
prop_primosSumaDeDosPrimos_equiv :: Int -> Property
prop_primosSumaDeDosPrimos_equiv n =
  n >= 0 ==>
  primosSumaDeDosPrimos !! n == primosSumaDeDosPrimos2 !! n

-- La comprobación es
--    λ> quickCheck prop_primosSumaDeDosPrimos_equiv
--    +++ OK, passed 100 tests.

-- Comparación de eficiencia
-- =========================

--    λ> primosSumaDeDosPrimos !! (10^4)
--    1261081
--    (2.07 secs, 4,540,085,256 bytes)
--
-- Se recarga para evitar memorización    
--    λ> primosSumaDeDosPrimos2 !! (10^4)
--    1261081
--    (0.49 secs, 910,718,408 bytes)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

import Data.Numbers.Primes (isPrime, primes)

-- 1ª solución

-- ===========

esPrimoSumaDeDosPrimos :: Integer -> Bool

esPrimoSumaDeDosPrimos x =

isPrime x && isPrime (x - 2)

primosSumaDeDosPrimos :: [Integer]

primosSumaDeDosPrimos =

[x | x <- primes

, isPrime (x - 2)]

-- 2ª solución

-- ===========

primosSumaDeDosPrimos2 :: [Integer]

primosSumaDeDosPrimos2 =

[y | (x,y) <- zip primes (tail primes)

, y == x + 2]

esPrimoSumaDeDosPrimos2 :: Integer -> Bool

esPrimoSumaDeDosPrimos2 x =

x == head (dropWhile (<x) primosSumaDeDosPrimos2)

-- Equivalencias

-- =============

-- Equivalencia de esPrimoSumaDeDosPrimos

prop_esPrimoSumaDeDosPrimos_equiv :: Integer -> Property

prop_esPrimoSumaDeDosPrimos_equiv x =

x > 0 ==>

esPrimoSumaDeDosPrimos x == esPrimoSumaDeDosPrimos2 x

-- La comprobación es

-- λ> quickCheck prop_esPrimoSumaDeDosPrimos_equiv

-- +++ OK, passed 100 tests.

-- Equivalencia de primosSumaDeDosPrimos

prop_primosSumaDeDosPrimos_equiv :: Int -> Property

prop_primosSumaDeDosPrimos_equiv n =

n >= 0 ==>

primosSumaDeDosPrimos !! n == primosSumaDeDosPrimos2 !! n

-- La comprobación es

-- λ> quickCheck prop_primosSumaDeDosPrimos_equiv

-- +++ OK, passed 100 tests.

-- Comparación de eficiencia

-- =========================

-- λ> primosSumaDeDosPrimos !! (10^4)

-- 1261081

-- (2.07 secs, 4,540,085,256 bytes)

--

-- Se recarga para evitar memorización

-- λ> primosSumaDeDosPrimos2 !! (10^4)

-- 1261081

-- (0.49 secs, 910,718,408 bytes)

Pensamiento

Sed incompresivos; yo os aconsejo la incomprensión, aunque sólo sea para destripar los chistes de los tontos.

Antonio Machado

6 Comentarios

import Data.Numbers.Primes (primes, isPrime)
 
esPrimoSumaDeDosPrimos :: Integer -> Bool
esPrimoSumaDeDosPrimos x
  | isPrime x = or [isPrime  (x-y)  | y <- takeWhile (<x) primes]
  | otherwise = False
                         
primosSumaDeDosPrimos :: [Integer]
primosSumaDeDosPrimos =
  [x | x <- [1..], esPrimoSumaDeDosPrimos x]

1

2

3

4

5

6

7

8

9

10

import Data.Numbers.Primes (primes, isPrime)

esPrimoSumaDeDosPrimos :: Integer -> Bool

esPrimoSumaDeDosPrimos x

| isPrime x = or [isPrime (x-y) | y <- takeWhile (<x) primes]

| otherwise = False

primosSumaDeDosPrimos :: [Integer]

primosSumaDeDosPrimos =

[x | x <- [1..], esPrimoSumaDeDosPrimos x]

import Data.Numbers.Primes (primes, isPrime)

esPrimoSumaDeDosPrimos :: Int -> Bool
esPrimoSumaDeDosPrimos x
  | isPrime x = x `elem` [w + y | w <- take x primes,
                                  y <- take x primes ]
  | otherwise = False

1

2

3

4

5

6

7

import Data.Numbers.Primes (primes, isPrime)

esPrimoSumaDeDosPrimos :: Int -> Bool

esPrimoSumaDeDosPrimos x

| isPrime x = x `elem` [w + y | w <- take x primes,

y <- take x primes ]

| otherwise = False

import Data.Numbers.Primes ( primes, isPrime)
 
esPrimoSumaDeDosPrimos :: Integer -> Bool
esPrimoSumaDeDosPrimos x
  = isPrime x && or [isPrime (x-y) | y<- takeWhile (<x) primes]
  
primosSumaDeDosPrimos :: [Integer]
primosSumaDeDosPrimos = [x | x <- [1..] , esPrimoSumaDeDosPrimos x]

1

2

3

4

5

6

7

8

import Data.Numbers.Primes ( primes, isPrime)

esPrimoSumaDeDosPrimos :: Integer -> Bool

esPrimoSumaDeDosPrimos x

= isPrime x && or [isPrime (x-y) | y<- takeWhile (<x) primes]

primosSumaDeDosPrimos :: [Integer]

primosSumaDeDosPrimos = [x | x <- [1..] , esPrimoSumaDeDosPrimos x]

import Data.Numbers.Primes (primes, isPrime)

esPrimoSumaDeDosPrimos :: Integer -> Bool
esPrimoSumaDeDosPrimos n
  | isPrime n = or [isPrime x | x <- takeWhile (<n-1) primes, n-2 == x]
  | otherwise = False
                          
primosSumaDeDosPrimos :: [Integer]
primosSumaDeDosPrimos = [x | x <- primes, esPrimoSumaDeDosPrimos x]

1

2

3

4

5

6

7

8

9

import Data.Numbers.Primes (primes, isPrime)

esPrimoSumaDeDosPrimos :: Integer -> Bool

esPrimoSumaDeDosPrimos n

| isPrime n = or [isPrime x | x <- takeWhile (<n-1) primes, n-2 == x]

| otherwise = False

primosSumaDeDosPrimos :: [Integer]

primosSumaDeDosPrimos = [x | x <- primes, esPrimoSumaDeDosPrimos x]

import Data.Numbers.Primes (primes, isPrime)

esPrimoSumaDeDosPrimos :: Integer -> Bool
esPrimoSumaDeDosPrimos x =
  isPrime x && elem x (take (fromIntegral x) sum2Prim)

sum2Prim :: [Integer]
sum2Prim = [a + b| a <- primes, b <- primes]

primosSumaDeDosPrimos :: [Integer]
primosSumaDeDosPrimos = [x | x <- primes, esPrimoSumaDeDosPrimos x]

1

2

3

4

5

6

7

8

9

10

11

import Data.Numbers.Primes (primes, isPrime)

esPrimoSumaDeDosPrimos :: Integer -> Bool

esPrimoSumaDeDosPrimos x =

isPrime x && elem x (take (fromIntegral x) sum2Prim)

sum2Prim :: [Integer]

sum2Prim = [a + b| a <- primes, b <- primes]

primosSumaDeDosPrimos :: [Integer]

primosSumaDeDosPrimos = [x | x <- primes, esPrimoSumaDeDosPrimos x]

import Data.Numbers.Primes (primes, isPrime)

esPrimoSumaDeDosPrimos :: Integer -> Bool
esPrimoSumaDeDosPrimos x =
  esPrimo x && elem x [a + b | a <- [1..x],
                               b <- [1..x],
                               esPrimo a,
                               esPrimo b]
 
esPrimo :: Integer -> Bool
esPrimo n = factores n == [1,n]
 
factores :: Integer -> [Integer]
factores n = [x | x <- [1..n], mod n x == 0]

1

2

3

4

5

6

7

8

9

10

11

12

13

14

import Data.Numbers.Primes (primes, isPrime)

esPrimoSumaDeDosPrimos :: Integer -> Bool

esPrimoSumaDeDosPrimos x =

esPrimo x && elem x [a + b | a <- [1..x],

b <- [1..x],

esPrimo a,

esPrimo b]

esPrimo :: Integer -> Bool

esPrimo n = factores n == [1,n]

factores :: Integer -> [Integer]

factores n = [x | x <- [1..n], mod n x == 0]

Escribe tu soluciónCancel reply