Terence Tao recentemente provou ser uma forma fraca da conjectura de Goldbach! Vamos explorá-lo!

Dado um número inteiro ímpar n > 1, escreva ncomo uma soma de até 5 números primos. Pegue a entrada como quiser e dê a saída como quiser. Por exemplo,

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

é um código sábio que recebe um número inteiro como entrada e retorna uma lista de números inteiros como saída cuja soma é n. Pelo teorema de Tao, isso sempre terminará!

Entrada

Um número inteiro ímpar n. Você decide como receber a entrada, mas se for estranho, explique-a.

Resultado

Bastante aberto. Retorne uma lista. Imprima uma string. Me dê um, alguns, ou todos. Deixe a porcaria na pilha (GS, Piet, etc) ou em um bloco de memória consecutivo (acessível) (BF, etc) de maneira previsível. Para esses casos posteriores, explique a saída. Em todos os casos, o que você devolve / imprime / o que deve ser uma representação direta de uma partição de nprimos com menos de 6 partes.

Pontuação

Isso é código de golfe, a menor contagem de bytes ganha.

Bônus! se a palavra 'goldbach' aparecer como uma subsequência (não necessariamente consecutiva; apenas em ordem. O caso não importa) do seu programa subtraia 8 pontos. O código acima é um exemplo disso.

J , 29

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

Assume que a entrada está inserida y. O valor da expressão é uma lista de caixas da lista de 5 primos ou 0 que somam y.

   y =. 16
   (# ~ 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 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 ...
+ ---------- + ---------- + ---------- + ---------- + ----- ----- + --------- + ---------- + ---------- + ---------- + - --------- + ---------- + ---------- + ---------- + ------- - + --------- + ---------- + ---------- + ---------- + ---- ------ + ---------- + ---------- + ---------- + --------- + ------...

Cartas insuficientes para ganhar pontos de bônus.

Mathematica , 38

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

C, 192-8 = 184 caracteres

Contém "Goldbach" consecutivamente (excluindo pontuação) e "Tao" também.
Quando a soma é menor do que 5 primos (ou seja, sempre), gravuras zeros (16 = 0+0+0+3+13)
Ler o número de entrada padrão: 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));
}

Versão antiga (179 caracteres), que pode encontrar apenas somas de exatamente 5 números primos (e, portanto, falha 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));
}

Explicação:
cdefine *bpara o próximo prime (incluindo*b ele próprio se for prime).
Tcria um loop for, que avança uma das variáveis G,o,l,d,apara o próximo prime.
Dentro de todos os loops, verificamos se a soma corresponde e, em seguida, imprimimos e saímos.

Braquilog , 9 bytes

~+.ṗᵐl≤5∧

Experimente online!

~+.          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.)

Rubi 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

Ligue com g(<number>). Saída de amostra:

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

Teste: http://ideone.com/rua7A

PHP 143 122 - 8 = 114

EDIT: salvou alguns bytes na saída, removeu a chamada de função explícita.

<?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
";}

Desenrolado:

<?
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
";}

Ligue com @g(<number>);saída de amostra 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 -rmathn, 66 bytes - 8 = 58

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

Fortemente baseado na resposta do GolfWolf, mas desde que tenho 6 anos, vou postar o meu próprio, em vez de dar uma olhada. Os avanços na tecnologia incluem o lambda stabby, usando em reducevez de injectde graça d, uma maneira concisa de parar nas partições de 5 e Prime.each(o)que itera sobre todos os números primos menores ou iguais a o(e fornece um ach). Talvez daqui a 6 anos haja uma maneira melhor de usar o 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)}}

Após a dica do boothby: eliminada uma chamada de função, permita interpretar 3 como a soma de 3 e nada, remova a entrada da saída - economiza outros 20 caracteres.

Bônus enfatizando:

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

Invocação e resultado:

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

A saída repete x para cada lista para somar xe, em seguida, mostra os 5 summands. 0 para summand ausente, ou seja, 2 + 2 + 13.

Ungolfed:

// 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 versão também imprimirá todas as permutações de todas as soluções:

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
...

E sim, ele cria uma lista muito longa g. Quem se importa? :-)

Versão não destruída:

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

Geléia , 19 bytes (mas muito lento - são necessários conselhos)

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

Experimente online!

Æ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!

Se você tiver alguma idéia para torná-lo mais rápido e mais curto, entre em contato!