Escriba un programa que solicite al usuario un número entero mayor que 2.

Dada la conjetura de Goldbach de que cada número entero mayor que 2 puede expresarse como la suma de dos números primos, imprime dos números primos que, cuando se suman, proporcionan el número par solicitado. Editar: el programa solo tiene que imprimir UN PAR de primos, no todos. Por ejemplo:

4: 2 + 2

6: 3 + 3

8: 3 + 5

10: 5 + 5 o 3 + 7

APL, 34 o 44 bytes

La primera versión tiene una longitud de 34 símbolos y está restringida a los caracteres de los conjuntos de caracteres APL de un solo byte originales, como el que aún se admite en Dyalog APL:

↑c/⍨n=+/¨c←,∘.,⍨v/⍨~v∊v∘.×v←1↓⍳n←⎕

Explicación:

                               n←⎕   ⍝ ask for a number, store as n
                          v←1↓⍳n     ⍝ generate all integers from 2 to n
                      v∘.×v          ⍝ compute the product table of any two such integers
                v/⍨~v∊               ⍝ select those that don't appear in the product table 
         c←,∘.,⍨                     ⍝ generate all possible pairs of these primes
    n=+/¨c                           ⍝ check which pairs have a sum equal to n
↑c/⍨                                 ⍝ take the first that does

La segunda versión tiene solo 22 símbolos de largo, porque explota la πfunción para verificar los números primos, pero eso solo está disponible en NARS2000 que usa Unicode, por lo que el recuento de bytes es 44 en UCS-2:

2⍴(⌿⍨{∧/0π⍵})(⍪,⌽)⍳⎕-1

Explicación:

                   ⎕    ⍝ ask for a number N
                  ⍳ -1  ⍝ generate all naturals from 1 to N-1
             (⍪,⌽)      ⍝ arrange it into a table of all pairs of naturals with sum N
     {∧/0π⍵}            ⍝ check which pairs are made of all primes
2⍴(⌿⍨       )           ⍝ return the first pair that does

Ejemplos

(⎕: es el mensaje que solicita un número)

      2⍴(⌿⍨{∧/0π⍵})(⍪,⌽)⍳⎕-1
⎕:
      4
2 2
      2⍴(⌿⍨{∧/0π⍵})(⍪,⌽)⍳⎕-1
⎕:
      6
3 3
      2⍴(⌿⍨{∧/0π⍵})(⍪,⌽)⍳⎕-1
⎕:
      8
3 5
      2⍴(⌿⍨{∧/0π⍵})(⍪,⌽)⍳⎕-1
⎕:
      124
11 113

Python 2, 75 71 bytes

n=input();k=m=1;p={0}
while{n-k,k}-p:m*=k*k;k+=1;p|={m%k*k}
print n-k,k

Pruébelo en Ideone .

Cómo funciona

Usamos un corolario del teorema de Wilson :

En todo momento, la variable m es igual al cuadrado del factorial de k - 1 ; k comienza en el valor 1 y m a valor 0! ² = 1 . El conjunto p consistirá en 0 y todos los números primos hasta el valor actual de k .

En cada iteración, primero verificamos si n - k y k pertenecen a p , lo cual es cierto si y solo si la diferencia establecida de {nk, k} y p está vacía. Si es así, la condición es falsa y el ciclo continúa.

Tenga en cuenta que k> 0 y {n - k, k} satisfarán la condición de algún valor positivo de n - k (suponiendo que la conjetura de Goldbach sea verdadera), por lo que el 0 en p no dará lugar a falsos positivos.

En el bucle, actualizamos k y m . El nuevo valor de m es m × k² = (k - 1)! ² × k² = k! ² , y el nuevo valor de k es k + 1 , entonces m = (k - 1)! ² aún se mantiene antes y después la actualización.

Luego, realizamos la unión de conjunto para agregar el valor de m% k × k a p . Según el corolario del teorema de Wilson, esto agregará 1 × k = k si k es primo y 0 × k = 0 si no.

Cuando finaliza el ciclo, imprimimos los últimos valores de n - k y k , que serán primos con suma n .

Rubí 2.0 (65)

require'prime'
n=gets.to_i
Prime.find{|i|p [i,n-i]if(n-i).prime?}

PHP - 73 bytes

<?for(;@($n%--$$n?:$o=&$argv[1]>$$n=++$n)||${++$b}^${--$o};);echo"$b+$o";

La entrada se toma como un argumento de línea de comando.

Uso de la muestra:

$ php goldbach.php 7098
19+7079

GolfScript 41 33 32

~(,2>.-1%]zip{{.,2>\{\%!}+,},!}?

Acepta argumentos de la línea de comandos, por ejemplo

echo "14" | ruby golfscript.rb goldbach.gs
-> [2 12]

Encuentra todas las particiones relevantes del número de entrada con:

(,2>.-1%]zip  #If only zip were a one-character command!  It is so often useful.

y luego encuentra la primera partición donde ningún número NO es primo con:

{np,!}? #For each partition, filter down to elements that are not prime, and only accept if there are no such results (since [] is falsey).

donde el bloque de comprobación compuesto npes:

{.,2>\{\%!}+,}

Este bloque se filtra a todos los números que dividen uniformemente un número dado. Si no hay tales números (entonces el número es primo), el resultado es [], que es falsey en GolfScript.

perl 6: 69

$/=get;for grep &is-prime,^$/ {exit say $_,$_-$/ if ($/-$_).is-prime}

R, 170 112 83 caracteres

a=scan();b=2:a;p=b[rowSums(!outer(b,b,`%%`))<2];q=p[(a-p)%in%p][1];cat(a,":",q,a-q)

Sangrado:

a=scan() #Take user input as a numeric
b=2:a
p=b[rowSums(!outer(b,b,`%%`))<2] #Find all primes from 2 to user input
q=p[(a-p)%in%p][1] #Check which a-p also belong to p and takes the first one
cat(a,":",q,a-q)

Uso:

> a=scan();b=2:a;p=b[rowSums(!outer(b,b,`%%`))<2];q=p[(a-p)%in%p][1];cat(a,":",q,a-q)
1: 72
2: 
Read 1 item
72 : 5 67 

Antigua solución a 112 caracteres, para posteridad

a=scan();b=2:a;p=b[rowSums(!outer(b,b,`%%`))<2];w=which(outer(p,p,`+`)==a,T);cat(a,":",p[w[1,1]],p[w[1,2]])

Sangrado:

a=scan()
b=2:a
p=b[rowSums(!outer(b,b,`%%`))<2]
w=which(outer(p,p,`+`)==a,T) #Find the index of valid combinations
cat(a,":",p[w[1,1]],p[w[1,2]]) #Prints the first valid combination

Python - 107

Básicamente, una mejora en la segunda parte de la respuesta de Nutria (ejecuté esto en 2.7 pero creo que también debería funcionar para 3.x)

p=lambda x:all(x%i!=0 for i in range(2,x))
n=input()
for i in range(2,n-1):
    if p(i)&p(n-i): print i,n-i

JavaScript (ES6) (Regex), 105

a=/^(xx+?)(?!(xx+)\2+$)x*(?=\1$)(?!(xx+)\3+$)/.exec("x".repeat(prompt()));alert(a[1].length+"+"+a[0].length)

Ahora tiene una expresión regular que prueba la conjetura de Goldbach, que tiene un bajo requerimiento de características especiales (soporte básico de referencia, retroalimentación positiva y negativa).

Esto utiliza String.prototype.repeat(), que es parte de la propuesta de EcmaScript sexta edición. Actualmente, este código solo funciona en Firefox.

Realmente necesito un lenguaje mejor que tenga un comando breve cuando trabajo con expresiones regulares ...

Scala, 286 192 172 148 caracteres

No es el más rápido pero funciona. Llame a g (10) para obtener la lista de pares de goldbach para 10.

def g(n:Int)={def p(n:Int,f:Int=2):Boolean=f>n/2||n%f!=0&&p(n,f+1)
s"$n : "+(for(i<-2 to n/2;j=n-i if p(i)&&p(j))yield s"$i + $j").mkString(" or ")}

La conversión a C ++ es sencilla.

C - 139 129 caracteres

a,b;i(x,y){return x>y?x%y?i(x,y+1):0:x>1;}main(){scanf("%i",&a);for(b=a/2;b-->1;)i(b,2)&&i(a-
b,2)&&printf("%i:%i+%i\n",a,b,a-b);}

newLISP - 169 148 caracteres

(define(p n)(=(length(factor n))1))
(define(g n)(when(even? n)(for(i 3 n 2)
(and(p i)(p(- n i))(println n {: } i { }(- n i))))))
(g(int(read-line)))

incluye el código para ejecutarlo. Los resultados son demasiado generosos ...

72: 5 67
72: 11 61
72: 13 59
72: 19 53
72: 29 43
72: 31 41
72: 41 31
72: 43 29
72: 53 19
72: 59 13
72: 61 11
72: 67 5

Sabio, 60

Similar en puntaje y sensación a la solución de res , pero creo que es lo suficientemente diferente como para publicar.

i=n=input()
while not{i,n-i}<set(primes(n)):i-=1
print i,n-i

Salvia , 65 62

n=input()
i=0
p=is_prime
while p(i)*p(n-i)==0:i+=1
print i,n-i

Con lo anterior en el archivo goldbach.sage, ejecútelo con Sage ejecutándose en una terminal:

sage: %runfile goldbach.sage 

Gracias a @boothby por la p=is_primeidea.

Haskell, 97C

g n=head[(a,b)|let q=p n,a<-q,b<-q,a+b==n]
p n=filter c[2..n]
c p=null[x|x<-[2..p-1],p`mod`x==0]

Explicación:

• ges la función "goldbach". Llamar g nte da el par de números primos que se suman n.
• pes una función que genera una lista de primos menores que n.
• ces la función de verificación principal utilizada para definir p.

Ejecuciones de ejemplo:

*Main> g 4
(2,2)
*Main> g 6
(3,3)
*Main> g 8
(3,5)
*Main> g 10
(3,7)
*Main> g 12
(5,7)
*Main> map g [4,6..100]
[(2,2),(3,3),(3,5),(3,7),(5,7),(3,11),(3,13),(5,13),(3,17),(3,19),(5,19),(3,23),(5,23),(7,23),(3,29),(3,31),(5,31),(7,31),(3,37),(5,37),(3,41),(3,43),(5,43),(3,47),(5,47),(7,47),(3,53),(5,53),(7,53),(3,59),(3,61),(5,61),(7,61),(3,67),(5,67),(3,71),(3,73),(5,73),(7,73),(3,79),(5,79),(3,83),(5,83),(7,83),(3,89),(5,89),(7,89),(19,79),(3,97)]

Mathematica 56

Esto devuelve todas las soluciones para el entero de entrada.

Select[Tuples[Prime@Range@PrimePi[n = Input[]], 2], Tr@# == n &]

Por ejemplo, cuando se ingresa 1298 ...

{{7, 1291}, {19, 1279}, {61, 1237}, {67, 1231}, {97, 1201}, {127, 1171}, {181, 1117}, {211, 1087}, { 229, 1069}, {277, 1021}, {307, 991}, {331, 967}, {379, 919}, {421, 877}, {439, 859}, {487, 811}, {541, 757}, {547, 751}, {571, 727}, {607, 691}, {691, 607}, {727, 571}, {751, 547}, {757, 541}, {811, 487} , {859, 439}, {877, 421}, {919, 379}, {967, 331}, {991, 307}, {1021, 277}, {1069, 229}, {1087, 211}, { 1117, 181}, {1171, 127}, {1201, 97}, {1231, 67}, {1237, 61}, {1279, 19}, {1291, 7}}

Tal como está escrito, devuelve cada solución dos veces.

Union[Sort/@ %]

{{7, 1291}, {19, 1279}, {61, 1237}, {67, 1231}, {97, 1201}, {127, 1171}, {181, 1117}, {211, 1087}, { 229, 1069}, {277, 1021}, {307, 991}, {331, 967}, {379, 919}, {421, 877}, {439, 859}, {487, 811}, {541, 757}, {547, 751}, {571, 727}, {607, 691}}

Julia, 62 caracteres (85 con aviso)

julia> g(n)=collect(filter((x)->sum(x)==n,combinations(primes(n),2)))
g (generic function with 1 method)

julia> g(88)
4-element Array{Array{Int64,1},1}:
 [5,83] 
 [17,71]
 [29,59]
 [41,47]

GTB , 31

Para su calculadora TI-84

`A:.5A→B@%;A,4)4$~B+1,B-1#~B,B&

Sin funciones integradas principales.

Ejecuciones de ejemplo

?4
               2
               2
?6
               3
               3
?8
               3
               5
?10
               5
               5

JavaScript 139 137 136

a=prompt();function b(n){for(i=2;i<n;i++)if(n%i<1)return;return 1}for(c=2,r=1;c<a&&r;c++)if(b(c)&&b(a-c))alert(a+": "+c+" + "+(a-c)),r=0

Python 3 - 150 143 caracteres

Versión anterior (150 caracteres):

p=lambda n:0 in[n % i for i in range(2,n)]
n=int(input())
[print('%d+%d'%(a, b))for b in range(2,n)for a in range(2,n)if not(a+b!=n or p(a) or p(b))]

Nueva versión (gracias a ProgramFOX):

p=lambda n:0 in[n%i for i in range(2,n)]
n=int(input())
[print('%d+%d'%(a,b))for b in range(2,n)for a in range(2,n)if not((a+b!=n)|p(a)|p(b))]

Imprime todas las combinaciones, por ejemplo:
4 2 + 2
10 7 + 3 5 + 5 3 + 7

q [116 caracteres]

y where all each{{2=count where 0=(x mod)each til x+1}each x}each y:{a where x=sum each a:a cross a:til x}"I"$read0 0

Sin función incorporada para encontrar el número primo.

Entrada

72

Salida

5  67
11 61
13 59
19 53
29 43
31 41
41 31
43 29
53 19
59 13
61 11
67 5

Python - 206

Un poco tarde para la fiesta, pero estoy practicando mis habilidades de golf.

¡Realmente codifiqué esto antes de encontrar esta pregunta! Entonces el mío no incluye la hermosa lambda que usan las otras soluciones de Python.

import math
def p(n):
    if n%2==0&n>2:return False
    for i in range(3,n):
        if n%i==0:return False
    return True 
X=int(input())
for i in range(2,X):
    if p(i)&p(X-i):print i,X-i;break

J - 35 32 char

"Preguntar al usuario" es la ruina de cada golfista J. ¡Ahí van todos mis personajes ganados con esfuerzo!

p:(n,n)#:i.&n,+/~p:i.n=:".1!:1]1

Explicado:

• ".1!:1]1- Leer en una cadena ( 1!:1) desde la entrada (identificador de archivo 1) y convertirlo en un número ( ".).
• p:i.n=:- Asigne este número a la variable ny luego tome los primeros nnúmeros primos.
• +/~- Hacer una tabla de suma, nancha y nalta.
• i.&n,- Convierta la tabla en una lista única, y luego encuentre el índice de la primera aparición de n, que existe si la conjetura de Goldbach es verdadera.
• p:(n,n)#: - Recupere la fila y la columna del índice, y tome los números primos correspondientes.

Uso:

   p:(n,n)#:i.&n,+/~p:i.n=:".1!:1]1
666
5 661
   p:(n,n)#:i.&n,+/~p:i.n=:".1!:1]1
1024
3 1021

Si el aviso no hubiera sido un requisito, aquí hay un verbo de 25 caracteres:

(,~p:@#:]i.~&,+/~@:p:@i.)

Jalea , 8 bytes (no competitiva)

_ÆRfÆR.ị

Pruébalo en línea!o verificar todos los casos de prueba .

Cómo funciona

_ÆRfÆR.ị  Main link. Argument: n (integer)

 ÆR       Prime range; yield all primes in [1, ..., n].
_         Subtract all primes from n.
   fÆR    Filter; intersect the list of differences with the prime range.
      .ị  At-index 0.5; yield the last and first element.

Julia, 50 49 bytes

~=primes;n=ARGS[]|>int
(n-~n)∩~n|>extrema|>show

Pruébalo en línea!

Si una función fuera aceptable, el código podría acortarse a 32 bytes :

~=primes
!n=(n-~n)∩~n|>extrema

Cómo funciona

~=primescrea un alias para la función de primos incorporada que devuelve una lista de todos los números primos hasta su argumento. n=ARGS[]|>intanaliza el primer argumento de la línea de comandos como lo guarda en n .

Para encontrar un par adecuado de primos, primero calculamos el rango de primos antes mencionado con ~n. Luego, n-~nproduce todas las diferencias de estos números primos y n .

Al intersecar ( ∩) el resultado con el rango primo en sí mismo, nos aseguramos de que los primos restantes p sean tales que n - p también sea primo.

Finalmente, extrematoma el primo más bajo y más alto en la intersección, por lo que su suma debe ser n .

SQL 295 284

En postgresql:

create function c(c int) returns table (n int, m int) as $$ 
with recursive i(n) as
(select 2 union all select n+1 from i where n<c), 
p as (select * from i a where not exists 
(select * from i b where a.n!=b.n and mod(a.n,b.n)=0))
select * from p a, p b where a.n+b.n=c 
$$ language sql;

Sin embargo, debería poder hacerlo en la mitad del espacio, si no fuera por cosas como "sin unión externa izquierda en la recursión", "sin subconsulta en la recursión" ...

Aquí está la salida:

postgres=# select c(10);
   c   
-------
 (3,7)
 (5,5)
 (7,3)
(3 rows)

postgres=# select c(88);
   c    
---------
 (5,83)
 (17,71)
 (29,59)
 (41,47)
 (47,41)
 (59,29)
 (71,17)
 (83,5)
(8 rows)

Lote - 266

@echo off&setLocal enableDelayedExpansion&for /L %%a in (2,1,%1)do (set/aa=%%a-1&set c=&for /L %%b in (2,1,!a!)do set/ab=%%a%%%%b&if !b!==0 set c=1
if !c! NEQ 1 set l=!l!%%a,)&for %%c in (!l!)do for %%d in (!l!)do set/ad=%%c+%%d&if !d!==%1 set o=%%c + %%d
echo !o!

Salir ordenadamente

@echo off
setLocal enableDelayedExpansion
for /L %%a in (2,1,%1) do (
    set /a a=%%a-1
    set c=
    for /L %%b in (2,1,!a!) do (
        set /a b=%%a%%%%b
        if !b!==0 set c=1
    )
    if !c! NEQ 1 set l=!l!%%a,
)
for %%c in (!l!) do for %%d in (!l!) do (
    set /a d=%%c+%%d
    if !d!==%1 set o=%%c + %%d
)
echo !o!

Perl 5, 58 bytes

57, más 1 para -nE

/^(11+?)(?!(11+)\2+$)1*(?=\1$)(?!(11+)\3+$)/;say for$1,$&

La entrada y la salida están en unario. Ejemplo:

$ perl -nE'/^(11+?)(?!(11+)\2+$)1*(?=\1$)(?!(11+)\3+$)/;say for$1,$&'
1111111111
111
1111111

Punta de sombrero.

Oracle SQL 11.2, 202 bytes

WITH v(x,y,s)AS(SELECT LEVEL,LEVEL,0 FROM DUAL CONNECT BY LEVEL<=:1 UNION ALL SELECT x,y-1,s+SIGN(MOD(x,y))FROM v WHERE y>1),p AS(SELECT x FROM v WHERE x-s=2)SELECT a.x,b.x FROM p a,p b WHERE:1=a.x+b.x;   

Sin golf

WITH v(x,y,s) AS
(
  SELECT LEVEL,LEVEL,0 FROM DUAL CONNECT BY LEVEL<=:1 
  UNION ALL 
  SELECT x,y-1,s+SIGN(MOD(x,y))FROM v WHERE y>1
)
,p AS (SELECT x FROM v WHERE x-s=2)
SELECT a.x,b.x 
FROM p a,p b 
WHERE :1=a.x+b.x;   

Python 3, 107 bytes

b=lambda x:all(x%y for y in range(2,x))
g=lambda x,i=2:((i,x-i)if b(i)&b(x-i)else g(x,i+1))if(i<x)else 0

b (x) es una prueba de primalidad para x, y g (x) recurre a través de números para encontrar dos primos que se ajusten.