¡Terence Tao demostró recientemente una forma débil de la conjetura de Goldbach! ¡Vamos a explotarlo!

Dado un número entero impar n > 1, escriba ncomo una suma de hasta 5 primos. Toma la entrada como quieras y da salida como quieras. Por ejemplo,

def g(o):
    for l in prime_range(o+1):
        if l == o:
            return l,
        for d in prime_range(l+1):
            for b in prime_range(d+1):
                if l+d+b == o:
                    return l,d,b
                for c in prime_range(b+1):
                    for h in prime_range(c+1):
                        if l+d+b+c+h == o:
                            return l,d,b,c,h

es un código Sage que toma un entero como entrada y devuelve una lista de enteros como salida cuya suma es n. ¡Según el teorema de Tao, esto siempre terminará!

Entrada

Un entero extraño n. Usted decide cómo tomar la entrada, pero si es raro, explíquela.

Salida

Más bien abierto. Devuelve una lista. Imprime una cadena. Dame uno, algunos o todos. Deje basura en la pila (GS, Piet, etc.) o en un bloque de memoria consecutivo (accesible) (BF, etc.) de manera predecible. Para estos casos posteriores, explique el resultado. En todos los casos, lo que devuelve / imprime / lo que debe ser debe ser una representación directa de una partición nen primos con menos de 6 partes.

Puntuación

Este es el código de golf, gana el conteo de bytes más pequeño.

¡Prima! si la palabra 'goldbach' aparece como una subsecuencia (no necesariamente consecutiva; solo en orden. El caso no importa) de su programa reste 8 puntos. El código anterior es un ejemplo de esto.

J , 29

(#~y=+/@>),{5$<0,p:i._1 p:>:y

Asume que la entrada está adentro y. El valor de la expresión es la lista de cuadros de la lista de 5 primos o 0 que suman y.

   y =. dieciséis
   (# ~ y = + / @>), {5 $ <0, p: i._1 p:>: y
+ ---------- + ---------- + ---------- + ---------- + ----- ----- + --------- + ---------- + ---------- + ---------- + - --------- + ---------- + ---------- + ---------- + ------- - + --------- + ---------- + ---------- + ---------- + ---- ------ + ---------- + ---------- + ---------- + --------- + ------...
| 0 0 0 3 13 | 0 0 0 5 11 | 0 0 0 11 5 | 0 0 0 13 3 | 0 0 2 3 11 | 0 0 2 7 7 | 0 0 2 11 3 | 0 0 3 0 13 | 0 0 3 2 11 | 0 0 3 11 2 | 0 0 3 13 0 | 0 0 5 0 11 | 0 0 5 11 0 | 0 0 7 2 7 | 0 0 7 7 2 | 0 0 11 0 5 | 0 0 11 2 3 | 0 0 11 3 2 | 0 0 11 5 0 | 0 0 13 0 3 | 0 0 13 3 0 | 0 2 0 3 11 | 0 2 0 7 7 | 0 2 0 ...
+ ---------- + ---------- + ---------- + ---------- + ----- ----- + --------- + ---------- + ---------- + ---------- + - --------- + ---------- + ---------- + ---------- + ------- - + --------- + ---------- + ---------- + ---------- + ---- ------ + ---------- + ---------- + ---------- + --------- + ------...

No hay suficientes letras para ganar puntos de bonificación.

Mathematica , 38

IntegerPartitions[n,5,Prime~Array~n,1]

C, 192-8 = 184 caracteres

Contiene "Goldbach" consecutivamente (excluyendo la puntuación) y "Tao" también.
Cuando la suma es inferior a 5 primos (es decir, siempre), imprime ceros (16 =0+0+0+3+13 )
Leer el número de la entrada estándar: echo 30 | ./prog.

#define T(x)for(x=0;x<=s;b=&x,c(++x))
G,o,l,d,*b,a;c(h)
{(*b-1?h<3:++*b)||c(*b%--h?h:++*b);}
main(s){
    scanf("%d",&s);
    T(G)T(o)T(l)T(d)T(a)o+G+l+d+a-s?0:exit(printf("%d+%d+%d+%d+%d\n",G,o,l,d,a));
}

Versión anterior (179 caracteres), que puede encontrar solo sumas de exactamente 5 primos (y por lo tanto falla para x <10):

#define T(x)for(x=2;x<s;b=&x,c(++x))
G,o,l,d,*b,a;c(h)
{h<3||c(*b%--h?h:++*b);}
main(s){
    scanf("%d",&s);
    T(G)T(o)T(l)T(d)T(a)o+G+l+d+a-s?0:exit(printf("%d+%d+%d+%d+%d\n",G,o,l,d,a));
}

Explicación: se
cestablece *ben el próximo primo (incluso *bsi es primo).
Tconstruye un bucle for, que avanza una de las variables G,o,l,d,aal siguiente primo.
Dentro de todos los bucles, verificamos si la suma coincide, e imprimimos y salimos si es así.

Brachylog , 9 bytes

~+.ṗᵐl≤5∧

Pruébalo en línea!

~+.          Output (.) should sum to the input,
   ṗᵐ        consist of all primes,
     l≤5     and have length ≤ 5.
        ∧    (Don't unify that 5 with the implicit output variable.)

Rubí 138 124 117-8 = 109

require'mathn'
def g(o,l=[])
p l if l.inject(:+)==o#db
(l.last||1..o).each{|d|d.prime?and g(o,l+[d])if l.count<5}
end

Llamada con g(<number>). Salida de muestra:

[2, 2, 2, 2, 19]
[2, 2, 3, 3, 17]
[2, 2, 3, 7, 13]
...

Prueba: http://ideone.com/rua7A

PHP 143 122 - 8 = 114

EDITAR: guardó algunos bytes en la salida, eliminó la llamada explícita a la función.

<?function g($o,$l,$d,$b){for(;$o>=$b=gmp_intval(gmp_nextprime(+$b));)echo$b^$o?$l<4&&g($o-$b,$l+1,"$d$b,",$b-1):"$d$b
";}

Desenrollado:

<?
function g($o,$l,$d,$b){
  for(;$o>=$b=gmp_intval(gmp_nextprime(+$b));)
    echo$b^$o?$l<4&&g($o-$b,$l+1,"$d$b,",$b-1):"$d$b
";}

Llamada con @g(<number>);salida de muestra para n=27:

2,2,2,2,19
2,2,3,3,17
2,2,3,7,13
2,2,5,5,13
2,2,5,7,11
2,2,23
2,3,3,19
2,3,5,17
2,3,11,11
2,5,7,13
2,7,7,11
3,3,3,5,13
3,3,3,7,11
3,3,5,5,11
3,3,7,7,7
3,5,5,7,7
3,5,19
3,7,17
3,11,13
5,5,5,5,7
5,5,17
5,11,11
7,7,13

Ruby 2 - arma, 66 bytes - 8 = 58

g=->o,*l{o==l.reduce(:+)?p(l):l[5]||b=Prime.each(o){|x|g[o,*l,x]}}

Basado en gran medida en la respuesta de GolfWolf, pero como tengo 6 años, voy a publicar la mía en lugar de picar. Los avances en tecnología incluyen el lambda stabby, que utiliza en reducelugar de injectla forma gratuita d, una forma concisa de detenerse en particiones de 5, y Prime.each(o), que itera sobre todos los números primos menores o iguales que o(y proporciona un ach). Tal vez en otros 6 años haya una mejor manera de usar el b.

Scala 137-8 = 129

def g(o:Int)={val l=0+:(2 to o).filterNot(d=>(2 to d-1).exists(d%_==0))
for(b<-l;a<-l;c<-l;h<-l;e<-l;if(b+a+c+h+e==o))yield{(b,a,c,h,e)}}

Después de la sugerencia de boothby: eliminó una llamada de función, permita interpretar 3 como la suma de 3 y nada, elimine la entrada de la salida; guarda otros 20 caracteres.

Bono enfatizando:

def g (o : Int) = {val l = 0 + :( 2 to o) .filterNot ( d => (2 to d-1) .exists (d% _ == 0)) para (b <-l ; a <-l; c <-l; h <-l; e <-l; if (b + a + c + h + e == o)) rendimiento {( b, a, c, h , e) }}

Invocación y resultado:

println (l(17)) 
Vector((17,0,0,2,2,13), (17,0,0,2,13,2), (17,0,0,3,3,11), ...

La salida repite x para cada lista para sumar x, y luego muestra los 5 sumandos. 0 para sumando falta, es decir, 2 + 2 + 13.

Sin golf:

// see if there is some x, such that o%x is 0.
def dividable (o:Int) = (2 to o-1).exists (x=> o % x == 0)

// +: is a kind of cons-operator for Vectors
def primelist (d: Int) = {
  val s = 0 +: (2 to d).filterNot (b => dividable (b))
  for (a <- s;
    b <- s;
    c <- s;
    h <- s;
    e <- s;
    if (a+b+c+h+e == d)) yield {(a,b,c,h,e)}
}

MuPAD 113 - 8 = 105

g:=[0,ithprime(i)$i=1..n]:f:=_for_in:f(l,g,f(d,g,f(b,g,f(a,g,f(c,g,if l+d+b+a+c=n then print(l,d,b,a,c)end)))))

Esta versión también imprimirá todas las permutaciones de cada solución:

0, 0, 0, 0, 7
0, 0, 0, 2, 5
0, 0, 0, 5, 2
0, 0, 0, 7, 0
0, 0, 2, 0, 5
...

Y sí, crea una lista demasiado larga g. ¿A quien le importa? :-)

Versión sin golf:

g:=[0].select([$1..n],isprime):
for l in g do
  for d in g do
    for b in g do
      for a in g do
        for c in g do
          if l+d+b+a+c=n then print(l,d,b,a,c); end;
        end
      end
    end
  end
end

Jelly , 19 bytes (pero muy lento, se necesitan consejos)

ÆR;0x5Œ!ḣ€5¹©S€i³ị®

Pruébalo en línea!

ÆR;0x5Œ!ḣ€5¹©€i³ị®     main link, takes one argument N
ÆR                     get all the primes less than N
  ;0x5                 add zero, and then repeat the entire list 5 times
      Œ!               get all the permutations of this huge list (takes a long time!)
        ḣ€5            for each permutation, just take the first 5 numbers
                       (this gives us all possible length-5 combinations of the primes plus zero, with some repeats)
           ¹©          save that list to register
              S€       take the sum of every permutation in the list...
                i³     and find the index of our first argument N in that list of sums
                  ị®   then recall our list of permutations, and get the correct permutation at that index!

Si tiene alguna idea para hacerlo más rápido y más corto, ¡hágamelo saber!