Menu Close

Ternas crecientes de primos con el mayor igual a la suma de los menores

Definir la función

   ternasPrimas :: [(Integer,Integer,Integer)]

tal que sus elementos son las ternas crecientes de primos con el mayor igual a la suma de los menores. Por ejemplo,

   ternasPrimas  ==  (2,3,5)
   ternasPrimas !! 34567  ==  (2,5393909,5393911)

Soluciones

import Data.Numbers.Primes (primes)
 
ternasPrimas :: [(Integer,Integer,Integer)]
ternasPrimas = [(2,a,b) | (a,b) <- zip (primes) (tail (primes)),
                          a + 2 == b]

Nuevas soluciones

  • En los comentarios se pueden escribir nuevas soluciones.
  • El código se debe escribir entre una línea con <pre lang="haskell"> y otra con </pre>
Inicial

4 soluciones de “Ternas crecientes de primos con el mayor igual a la suma de los menores

  1. Rubén Muñoz Mkrtchian
    import Data.Numbers.Primes (primes, isPrime)
     
    -- Antes de definir la función debemos tener en cuenta una cosa. A la hora de
    -- sumar dos números pueden ocurrir dos casos:
    --   + Si sumamos dos números pares o dos números impares el resultado es un
    --     número par. Como el único número par primo es el 2 y no se puede obtener
    --     como suma de dos primos impares, y además la suma de dos primos impares
    --     no resulta nunca en un número primo, se debe dar el siguiente caso.
    --   + Si sumamos un número par y otro impar, obtenemos un número impar. Así
    --     pues, la única forma de obtener las ternas primas pedidas es sumando un
    --     número primo par (necesariamente el 2) con otro primo impar.
     
    ternasPrimas :: [(Integer,Integer,Integer)]
    ternasPrimas = [(2,n,m) | n <- tail primes, let m = n + 2, isPrime m]
  2. Joaquín Infante Rodríguez
    import Data.List
    import Data.Numbers.Primes
     
    ternasPrimas1 :: [(Integer,Integer,Integer)]
    ternasPrimas1  = [(a,b,a+b) | b<-primes , a<-(genericTake (b-1) primes), isPrime (a+b)]
     
    --Dado que el primer elemento siempre será el 2, pues habrá infinitas ternas primas con el 2 como primer elemento, una definición más eficiente de la función es: 
     
    ternasPrimas :: [(Integer,Integer,Integer)]
    ternasPrimas  = [(2,a,2+a) | a<-primes , isPrime (2+a)]
  3. Alejandro García Alcaide
    -- TERNAS CRECIENTES DE PRIMOS 
    import Data.Numbers.Primes
    -- Debemos tener en cuenta que la suma de dos numeros pares nunca sera
    -- primo(pues el resultado es par). Por otro lado, la suma de dos impares
    -- siempre es par y, por tanto, nunca sera primo. Asi, la unica
    -- combinacion  posible es la suma de un par y un impar.
     
    -- El unico par primo es el dos; luego, el primer elemento de la terna será el
    -- 2. Dado que z (en la terna (x,y,z)) debe ser la suma de los dos anteriores,
    -- tendremos:
     
    ternasPrimas :: [(Integer,Integer,Integer)]
    ternasPrimas = [(2,y,(2+y)) | y <- tail (primes), isPrime (2+y)]
  4. Carlos Manzano Díaz
    import Data.Numbers.Primes
     
    ternasPrimas2 :: [(Integer,Integer,Integer)]
    ternasPrimas2 = [ (2,x-2,x) | x <- primes, isPrime (x-2)]

Leave a Reply

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.