Terence Tao hat kürzlich eine schwache Form von Goldbachs Vermutung bewiesen! Lasst es uns ausnutzen!

Bei einer ungeraden Ganzzahl n > 1schreiben Sie nals Summe von bis zu 5 Primzahlen. Nehmen Sie die Eingabe, wie Sie möchten, und geben Sie die Ausgabe, wie Sie möchten. Beispielsweise,

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

is Sage-Code, der eine Ganzzahl als Eingabe annimmt und eine Liste von Ganzzahlen als Ausgabe zurückgibt, deren Summe gleich ist n. Nach dem Satz von Tao endet dies immer!

Eingang

Eine ungerade ganze Zahl n. Sie entscheiden, wie Sie die Eingabe aufnehmen, aber wenn es komisch ist, erklären Sie es.

Ausgabe

Eher offen. Gib eine Liste zurück. Einen String drucken. Gib mir eins, ein paar oder alles. Lassen Sie Mist auf vorhersehbare Weise auf dem Stapel (GS, Piet usw.) oder in einem aufeinanderfolgenden (erreichbaren) Speicherblock (BF usw.) herumliegen. Erklären Sie für diese späteren Fälle die Ausgabe. In allen Fällen sollte das, was Sie zurückgeben / drucken / was Sie haben, eine einfache Darstellung einer Aufteilung nin Primzahlen mit weniger als 6 Teilen sein.

Wertung

Dies ist Codegolf, die kleinste Anzahl an Bytes gewinnt.

Bonus! Wenn das Wort "Goldbach" als Teilfolge (nicht unbedingt aufeinanderfolgend; nur in der richtigen Reihenfolge. Groß- und Kleinschreibung spielt keine Rolle) Ihres Programms erscheint, ziehen Sie 8 Punkte ab. Der obige Code ist ein Beispiel dafür.

J , 29

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

Angenommen, die Eingabe ist in y. Der Wert des Ausdrucks ist eine Liste von Feldern mit einer Liste von 5 Primzahlen oder einer Summe von 0 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 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 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 13 3 0 | 0 2 0 3 11 | 0 2 0 7 7 | 0 2 0 ...
+ ---------- + ---------- + ---------- + ---------- + ----- ----- + --------- + ---------- + ---------- + ---------- + - --------- + ---------- + ---------- + ---------- + ------- - + --------- + ---------- + ---------- + ---------- + ---- ------ + ---------- + ---------- + ---------- + --------- + ------...

Nicht genug Buchstaben, um Bonuspunkte zu verdienen.

Mathematica , 38

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

C, 192-8 = 184 Zeichen

Enthält fortlaufend "Goldbach" (ohne Satzzeichen) und "Tao".
Wenn die Summe kleiner ist als 5 Primzahlen (dh immer), druckt Nullen (16 = 0+0+0+3+13)
Lesen Sie die Nummer von der Standardeingabe: 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));
}

Alte Version (179 Zeichen), die nur Summen von genau 5 Primzahlen findet (und daher für x <10 fehlschlägt):

#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));
}

Erklärung:
cSetzt *bauf die nächste Primzahl (einschließlich sich *bselbst, wenn es sich um eine Primzahl handelt).
TErstellt eine for-Schleife, mit der eine der Variablen G,o,l,d,aauf die nächste Primzahl vorgerückt wird.
In allen for-Schleifen prüfen wir, ob die Summe übereinstimmt, und drucken und beenden, falls dies der Fall ist.

Brachylog , 9 Bytes

~+.ṗᵐl≤5∧

Probieren Sie es 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

Mit anrufen g(<number>). Beispielausgabe:

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

Test: http://ideone.com/rua7A

PHP 143 122 - 8 = 114

BEARBEITEN: Einige Bytes bei der Ausgabe gespeichert, der explizite Funktionsaufruf entfernt.

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

Abgerollt:

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

Aufruf mit @g(<number>);Beispielausgabe für 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]}}

Stark basierend auf der Antwort von GolfWolf, aber da es 6 Jahre alt ist, werde ich meine eigenen posten, anstatt zu picken. Zu den technologischen Fortschritten gehört das Stabby-Lambda, das reduceanstelle des injectfreien deine knappe Methode zum Anhalten an Partitionen von 5 verwendet und Prime.each(o)das über alle Primzahlen iteriert, die kleiner oder gleich sind o(und eine liefern ach). Vielleicht gibt es in weiteren 6 Jahren eine bessere Möglichkeit, die 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)}}

Nach Boothby's Tipp: Einen Funktionsaufruf eliminieren, 3 als Summe von 3 und nichts interpretieren lassen, Eingabe von Ausgabe entfernen - weitere 20 Zeichen sparen.

Bonus mit Schwerpunkt auf:

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

Aufruf und Ergebnis:

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

Die Ausgabe wiederholt x für jede Liste, um x zu addieren, und zeigt dann die 5 Summanden an. 0 für fehlenden Summanden, dh 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)))))

Diese Version druckt auch alle Permutationen jeder Lösung:

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

Und ja, es erstellt eine viel zu lange Liste g. Wen interessiert das? :-)

Ungolfed-Version:

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 (aber sehr langsam - Beratung erwünscht)

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

Probieren Sie es 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!

Wenn Sie Ideen haben, es schneller und kürzer zu machen, lassen Sie es mich bitte wissen!