Terence Tao gần đây đã chứng minh một dạng phỏng đoán yếu của Goldbach! Hãy khai thác nó!

Cho một số nguyên lẻ n > 1, viết ndưới dạng tổng của tối đa 5 số nguyên tố. Lấy đầu vào theo cách bạn thích và đưa ra đầu ra theo cách bạn thích. Ví dụ,

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

là mã Sage lấy một số nguyên làm đầu vào và trả về danh sách các số nguyên làm đầu ra có tổng n. Theo định lý của Tao, điều này sẽ luôn chấm dứt!

Đầu vào

Một số nguyên lẻ n. Bạn quyết định làm thế nào để lấy đầu vào, nhưng nếu nó lạ, hãy giải thích nó.

Đầu ra

Khá cởi mở. Trả về một danh sách. In một chuỗi. Đưa tôi một, một vài, hoặc tất cả. Để crap nằm xung quanh trên ngăn xếp (GS, Piet, v.v.) hoặc trong một khối bộ nhớ liên tiếp (có thể tiếp cận) (BF, v.v.) theo cách có thể dự đoán được. Đối với những trường hợp sau này, giải thích đầu ra. Trong mọi trường hợp, những gì bạn trả về / in / whathaveyou phải là một biểu diễn đơn giản của một phân vùng nthành các số nguyên tố có ít hơn 6 phần.

Chấm điểm

Đây là mã golf, số byte nhỏ nhất sẽ thắng.

Tặng kem! nếu từ 'goldbach' xuất hiện như một phần tiếp theo (không nhất thiết phải liên tiếp; chỉ theo thứ tự. Trường hợp không quan trọng) của chương trình của bạn trừ 8 điểm. Mã ở trên là một ví dụ về điều này.

J , 29

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

Giả sử đầu vào là trong y. Giá trị của biểu thức là danh sách các hộp danh sách gồm 5 số nguyên tố hoặc 0 tổng 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 ...
+ ---------- + ---------- + ---------- + ---------- + ----- ----- + --------- + ---------- + ---------- + ---------- + - --------- + ---------- + ---------- + ---------- + ------- - + --------- + ---------- + ---------- + ---------- + ---- ------ + ---------- + ---------- + ---------- + --------- + ------...

Không đủ chữ cái để kiếm bất kỳ điểm thưởng.

Toán học , 38

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

C, 192-8 = 184 ký tự

Chứa "Goldbach" liên tiếp (không bao gồm dấu chấm câu) và "Tao" là tốt.
Khi tổng nhỏ hơn 5 số nguyên tố (nghĩa là luôn luôn), in số không (16 = 0+0+0+3+13)
Đọc số từ đầu vào tiêu chuẩn : 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));
}

Phiên bản cũ (179 ký tự), chỉ có thể tìm thấy tổng của 5 số nguyên tố (và do đó không thành công cho 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));
}

Giải thích:
cđặt *bthành số nguyên tố tiếp theo (bao gồm *bchính nó nếu nó là số nguyên tố).
Txây dựng một vòng lặp for, tiến một trong các biến G,o,l,d,asang số nguyên tố tiếp theo.
Trong tất cả các vòng lặp, chúng tôi kiểm tra xem tổng có khớp hay không, và in và thoát nếu có.

Brachylog , 9 byte

~+.ṗᵐl≤5∧

Hãy thử trực tuyến!

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

Gọi với g(<number>). Đầu ra mẫu:

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

Kiểm tra: http://ideone.com/rua7A

PHP 143 122 - 8 = 114

EDIT: Đã lưu một vài byte trên đầu ra, loại bỏ lệnh gọi hàm rõ ràng.

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

Chưa được kiểm soát:

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

Gọi với @g(<number>);đầu ra mẫu cho 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]}}

Dựa nhiều vào câu trả lời của GolfWolf, nhưng từ năm 6 tuổi, tôi sẽ đăng bài của riêng mình thay vì nitpicking. Những tiến bộ trong công nghệ bao gồm lambda mạnh mẽ, sử dụng reducethay vì injectmiễn phí d, một cách dừng lại ngắn gọn tại các phân vùng 5 và Prime.each(o)lặp đi lặp lại trên tất cả các số nguyên tố nhỏ hơn hoặc bằng o(và cung cấp một ach). Có lẽ trong 6 năm nữa sẽ có cách sử dụng tốt hơn 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)}}

Sau gợi ý của boothby: đã loại bỏ một lệnh gọi hàm, cho phép hiểu 3 là tổng của 3 và không có gì, loại bỏ đầu vào khỏi đầu ra - lưu thêm 20 ký tự khác.

Phần thưởng nhấn mạnh:

def g (o : Int) = {val l = 0 + :( 2 đến o) .filterNot ( d => (2 đến d-1) .exists (d% _ == 0)) cho (b <-l ; a <-l; c <-l; h <-l; e <-l; if (b + a + c + h + e == o)) mang lại {( b, a, c, h , e) }}

Yêu cầu và kết quả:

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

Đầu ra lặp lại x cho mỗi danh sách để tổng hợp lên x, và sau đó hiển thị 5 triệu hồi. 0 cho thiếu summand, tức là 2 + 2 + 13.

Ung dung:

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

Phiên bản này cũng sẽ in tất cả các hoán vị của mọi giải pháp:

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

Và vâng, nó tạo ra một danh sách quá dài g. Ai quan tâm? :-)

Phiên bản bị đánh cắp:

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 (nhưng rất chậm - muốn có lời khuyên)

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

Hãy thử trực tuyến!

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

Nếu bạn có bất kỳ ý tưởng nào để làm cho nó nhanh hơn và ngắn hơn, xin vui lòng cho tôi biết!