Terence Tao ostatnio udowodnił słabą formę przypuszczeń Goldbacha! Wykorzystajmy to!

Biorąc pod uwagę nieparzystą liczbę całkowitą n > 1, napisz njako sumę do 5 liczb pierwszych. Wprowadź dane wejściowe w dowolny sposób i przekaż dane wyjściowe w dowolny sposób. Na przykład,

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

to kod Sage, który przyjmuje liczbę całkowitą jako dane wejściowe i zwraca listę liczb całkowitych jako dane wyjściowe, których suma wynosi n. Zgodnie z twierdzeniem Tao to się zawsze skończy!

Wejście

Dziwna liczba całkowita n. Ty decydujesz, jak wykorzystać dane wejściowe, ale jeśli to dziwne, wyjaśnij to.

Wynik

Raczej otwarty. Zwróć listę. Wydrukuj ciąg. Daj mi jeden, kilka lub wszystkie. Zostaw bzdury leżące na stosie (GS, Piet itp.) Lub w kolejnym (osiągalnym) bloku pamięci (BF itp.) W przewidywalny sposób. W tych późniejszych przypadkach wyjaśnij dane wyjściowe. We wszystkich przypadkach to, co zwracasz / drukujesz / co powinieneś, powinno być prostą reprezentacją podziału nna liczby pierwsze z mniej niż 6 częściami.

Punktacja

To jest golf golfowy, wygrywa najmniejsza liczba bajtów.

Premia! jeśli słowo „goldbach” pojawia się jako podsekwencja (niekoniecznie kolejne; tylko w kolejności. Wielkość liter nie ma znaczenia) w twoim programie odejmij 8 punktów. Powyższy kod jest tego przykładem.

J , 29

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

Zakłada, że ​​wejście jest w y. Wartością wyrażenia jest lista pól listy 5 liczb pierwszych lub 0, które sumują się 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 ...
+ ---------- + ---------- + ---------- + ---------- + ----- ----- + --------- + ---------- + ---------- + ---------- + - --------- + ---------- + ---------- + ---------- + ------- - + --------- + ---------- + ---------- + ---------- + ---- ------ + ---------- + ---------- + ---------- + --------- + ------...

Za mało liter, aby zdobyć punkty bonusowe.

Mathematica , 38

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

C, 192–8 = 184 znaki

Zawiera kolejno „Goldbach” (bez interpunkcji) i „Tao”.
Gdy suma jest mniejsza niż 5 liczb pierwszych (czyli zawsze), grafiki (16 zer = 0+0+0+3+13)
Czytaj liczbę ze standardowego wejścia: 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));
}

Stara wersja (179 znaków), która może znaleźć tylko sumy dokładnie 5 liczb pierwszych (i dlatego zawiedzie dla 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));
}

Objaśnienie:
custawia *bnastępną liczbę pierwszą (w tym *bsamą siebie, jeśli jest liczbą pierwszą).
Tbuduje pętlę for, która przesuwa jedną ze zmiennych G,o,l,d,ado następnej liczby pierwszej.
We wszystkich pętlach sprawdzamy, czy suma się zgadza, a jeśli tak, to drukujemy i kończymy.

Brachylog , 9 bajtów

~+.ṗᵐl≤5∧

Wypróbuj 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

Zadzwoń z g(<number>). Przykładowe dane wyjściowe:

[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

EDYCJA: Zapisano kilka bajtów na wyjściu, usunięto jawne wywołanie funkcji.

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

Rozwinięty:

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

Zadzwoń z @g(<number>);przykładowym wyjściem dla 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 - rathath, 66 bajtów - 8 = 58

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

Mocno oparty na odpowiedzi GolfWolf, ale ponieważ ma on 6 lat, zamierzam opublikować własną zamiast naciągania. Postępy technologiczne obejmują mocną lambda, używającą reducezamiast injectza darmo d, zwięzłego sposobu zatrzymywania się na partycjach 5, i Prime.each(o)który iteruje po wszystkich liczbach pierwszych mniejszych lub równych o(i dostarcza an ach). Może za 6 lat będzie lepszy sposób korzystania z 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)}}

Po wskazówce Boothby: wyeliminowano jedno wywołanie funkcji, pozwól zinterpretować 3 jako sumę 3 i nic, usuń dane wejściowe z wyjścia - zapisuje kolejne 20 znaków.

Premia podkreślająca:

def g (o : Int) = {val l = 0 + :( 2 do o). filterNot ( d => (2 do d-1). istnieje (d% _ == 0)) dla (b <-l ; a <-l; c <-l; h <-l; e <-l; if (b + a + c + h + e == o)) wydajność {( b, a, c, h , e) }}

Wywołanie i wynik:

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

Wyjście powtarza x dla każdej listy, aby zsumować do x, a następnie pokazuje 5 sum. 0 za brakujący summand, tj. 2 + 2 + 13.

Nie golfowany:

// 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)))))

Ta wersja wydrukuje również wszystkie permutacje każdego rozwiązania:

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

I tak, tworzy zbyt długą listę g. Kogo to obchodzi? :-)

Wersja bez golfa:

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

Galaretka , 19 bajtów (ale bardzo wolno - potrzebna rada)

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

Wypróbuj 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!

Jeśli masz jakieś pomysły, aby uczynić go szybszym i krótszym, daj mi znać!