Terence Tao baru-baru ini membuktikan bentuk dugaan Goldbach yang lemah! Mari kita manfaatkan!

Diberikan bilangan bulat ganjil n > 1, tulis nsebagai jumlah hingga 5 bilangan prima. Ambil input sesuka Anda, dan berikan output sesuka Anda. Sebagai contoh,

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

adalah kode Sage yang mengambil integer sebagai input, dan mengembalikan daftar integer sebagai output yang jumlahnya n. Dengan teorema Tao, ini akan selalu berakhir!

Memasukkan

Bilangan bulat ganjil n. Anda memutuskan bagaimana mengambil input, tetapi jika aneh, jelaskan.

Keluaran

Agak terbuka. Kembalikan daftar. Cetak string. Berikan satu, beberapa, atau semua. Biarkan sampah tergeletak di tumpukan (GS, Piet, dll) atau dalam blok memori (dapat dicapai) berturut-turut (BF, dll) dengan cara yang dapat diprediksi. Untuk kasus-kasus selanjutnya, jelaskan hasilnya. Dalam semua kasus, apa yang Anda kembalikan / cetak / ketika Anda harus menjadi representasi langsung dari partisi nmenjadi bilangan prima dengan kurang dari 6 bagian.

Mencetak gol

Ini adalah kode golf, jumlah byte terkecil yang menang.

Bonus! jika kata 'goldbach' muncul sebagai urutan (tidak harus berturut-turut; hanya dalam urutan. Kasus tidak masalah) dari program Anda kurangi 8 poin. Kode di atas adalah contohnya.

J , 29

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

Asumsikan input dalam y. Nilai ekspresi adalah daftar kotak daftar 5 bilangan prima atau 0 yang dijumlahkan 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 ...
+ ---------- + ---------- + ---------- + ---------- + ----- ----- + --------- + ---------- + ---------- + ---------- + - --------- + ---------- + ---------- + ---------- + ------- - + --------- + ---------- + ---------- + ---------- + ---- ------ + ---------- + ---------- + ---------- + --------- + ------ ...

Tidak cukup surat untuk mendapatkan poin bonus.

Mathematica , 38

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

C, 192-8 = 184 karakter

Berisi "Goldbach" secara berurutan (tidak termasuk tanda baca), dan "Tao" juga.
Ketika jumlahnya adalah kurang dari 5 bilangan prima (yaitu selalu), cetakan angka nol (16 = 0+0+0+3+13)
Baca jumlah dari masukan standar: 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 lama (179 karakter), yang hanya dapat menemukan jumlah tepat 5 bilangan prima (dan karenanya gagal untuk 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));
}

Penjelasan:
cmengatur *bke prime berikutnya (termasuk *bdirinya sendiri jika prime).
Tmembangun for for, yang memajukan salah satu variabel G,o,l,d,ake prime berikutnya.
Dalam semua untuk loop, kami memeriksa apakah jumlahnya cocok, dan mencetak & keluar jika benar.

Brachylog , 9 byte

~+.ṗᵐl≤5∧

Cobalah 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

Panggil dengan g(<number>). Output sampel:

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

Uji: http://ideone.com/rua7A

PHP 143 122 - 8 = 114

EDIT: Menyimpan beberapa byte pada output, menghapus panggilan fungsi eksplisit.

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

Belum dibuka:

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

Panggil dengan @g(<number>);Output sampel untuk 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]}}

Sangat berdasarkan jawaban GolfWolf, tetapi karena sudah berusia 6 tahun saya akan memposting sendiri bukan nitpicking. Kemajuan teknologi termasuk lambda yang stabby, menggunakan reducealih-alih injectsecara gratis d, cara singkat untuk berhenti di partisi 5, dan Prime.each(o), yang bergerak di atas semua bilangan prima kurang dari atau sama dengan o(dan melengkapi sebuah ach). Mungkin dalam 6 tahun lagi akan ada cara yang lebih baik untuk menggunakan 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)}}

Setelah petunjuk boothby: menghilangkan satu panggilan fungsi, izinkan untuk menafsirkan 3 sebagai jumlah dari 3 dan tidak ada, menghapus input dari output - menyimpan 20 karakter lainnya.

Bonus yang menekankan:

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

Doa dan hasil:

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

Output berulang x untuk setiap daftar untuk jumlah hingga x, dan kemudian menunjukkan 5 puncak. 0 untuk puncak yang hilang, yaitu 2 + 2 + 13.

Tidak Terkumpul:

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

Versi ini juga akan mencetak semua permutasi dari setiap solusi:

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

Dan ya, itu membuat daftar yang terlalu panjang g. Siapa peduli? :-)

Versi tidak disatukan:

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 (tetapi sangat lambat - saran ingin)

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

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

Jika Anda punya ide untuk membuatnya lebih cepat dan lebih pendek, beri tahu saya!