Terence Tao ha recentemente dimostrato una forma debole della congettura di Goldbach! Sfruttiamolo!

Dato un numero intero dispari n > 1, scrivi ncome somma di un massimo di 5 numeri primi. Prendi l'input come preferisci e dai l'output nel modo che preferisci. Per esempio,

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

è il codice Sage che accetta un numero intero come input e restituisce un elenco di numeri interi come output la cui somma è n. Secondo il teorema di Tao, questo finirà sempre!

Ingresso

Un numero intero dispari n. Decidi tu come prendere l'input, ma se è strano, spiegalo.

Produzione

Piuttosto aperto. Restituisce un elenco. Stampa una stringa. Dammi uno, pochi o tutti. Lasciare le cazzate in giro sullo stack (GS, Piet, ecc.) O in un blocco di memoria consecutivo (raggiungibile) (BF, ecc.) In modo prevedibile. Per questi casi successivi, spiegare l'output. In ogni caso, ciò che restituisci / stampa / che cosa dovrebbe essere una rappresentazione diretta di una partizione nin numeri primi con meno di 6 parti.

punteggio

Questo è il golf del codice, vince il conteggio dei byte più piccolo.

Bonus! se la parola "goldbach" appare come una sottosequenza (non necessariamente consecutiva; solo nell'ordine. Il caso non ha importanza) del programma sottrarre 8 punti. Il codice sopra è un esempio di questo.

J , 29

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

Presuppone che sia inserito y. Il valore dell'espressione è un elenco di caselle con un elenco di 5 numeri primi o 0 che sommano 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 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 ...
+ ---------- + ---------- + ---------- + ---------- + ----- ----- + --------- + ---------- + ---------- + ---------- + - --------- + ---------- + ---------- + ---------- + ------- - + --------- + ---------- + ---------- + ---------- + ---- ------ + ---------- + ---------- + ---------- + --------- + ------...

Non abbastanza lettere per guadagnare punti bonus.

Mathematica , 38

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

C, 192-8 = 184 caratteri

Contiene "Goldbach" consecutivamente (esclusa la punteggiatura) e anche "Tao".
Quando la somma è inferiore a 5 primi (cioè sempre), stampe zeri (16 = 0+0+0+3+13)
Leggere il numero dall'input standard: 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));
}

Vecchia versione (179 caratteri), che può trovare solo somme di esattamente 5 numeri primi (e quindi non riesce per 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));
}

Spiegazione:
cimposta *bil primo successivo (incluso *bse stesso se è primo).
Tcrea un ciclo for, che fa avanzare una delle variabili G,o,l,d,aal prossimo primo.
All'interno di tutti i loop, controlliamo se la somma corrisponde e stampiamo ed esci se lo fa.

Brachylog , 9 byte

~+.ṗᵐl≤5∧

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

Ruby 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

Chiama con g(<number>). Uscita campione:

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

Test: http://ideone.com/rua7A

PHP 143 - 8 = 114

EDIT: salvato alcuni byte sull'output, rimossa la chiamata di funzione esplicita.

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

srotolato:

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

Chiama con @g(<number>);output di esempio per 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 byte - 8 = 58

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

Fortemente basato sulla risposta di GolfWolf, ma da quando ha 6 anni pubblicherò il mio invece di fare il nitpicking. I progressi nella tecnologia includono lo stabby lambda, usando reduceinvece che injectper libero d, un modo conciso di fermarsi alle partizioni di 5, e Prime.each(o), che scorre su tutti i numeri primi uguali o uguali a o(e fornisce un ach). Forse tra altri 6 anni ci sarà un modo migliore di usare il 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)}}

Dopo il suggerimento di boothby: eliminata una chiamata di funzione, consente di interpretare 3 come la somma di 3 e niente, rimuove l'input dall'output - salva altri 20 caratteri.

Enfasi sul bonus:

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

Invocazione e risultato:

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

L'output ripete x per ogni elenco per riassumere fino a x, quindi mostra i 5 riassunti. 0 per summand mancante, ovvero 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)))))

Questa versione stamperà anche tutte le permutazioni di ogni soluzione:

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 sì, crea un elenco troppo lungo g. Che importa? :-)

Versione non golfata:

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 byte (ma molto lento - consiglio desiderato)

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

Provalo 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 hai qualche idea per renderlo più veloce e più breve, fammi sapere!