陶仁涛最近证明了哥德巴赫猜想的一种弱形式！让我们利用它！

给定一个奇数整数n > 1，n最多写5个素数。随心所欲输入，随心所欲输出。例如，

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

是Sage代码，它将整数作为输入，并返回一个整数列表作为输出，其和为n。根据陶定理，这将永远终止！

输入值

一个奇数整数n。您可以决定如何接受输入，但是如果很奇怪，请解释一下。

输出量

相当开放。返回列表。打印一个字符串。给一个，几个或全部。将废话以可预测的方式放在堆栈（GS，Piet等）上或连续（可访问）的内存块（BF等）中。对于这些以后的情况，请解释输出。在所有情况下，退货/打印/拥有的内容应该是n素数分区少于6个部分的简单表示。

计分

这是代码高尔夫，最小的字节数获胜。

奖金！如果“哥德巴赫”一词出现在程序的子序列中（不一定是连续的；只是顺序。大小写无关紧要），请减去8分。上面的代码就是一个例子。

Ĵ，29

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

假设输入在中y。表达式的值是5个素数或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 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 ...
+ ---------- + ---------- + ---------- + ---------- + ----- ----- + --------- + ---------- + ---------- + ---------- +- --------- + ---------- + ---------- + ---------- + ------- -+ --------- + ---------- + ---------- + ---------- + ---- ------ + ---------- + ---------- + ---------- + --------- + ------...

没有足够的字母来赚取任何奖励积分。

Mathematica，38岁

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

C，192-8 = 184个字符

连续包含“戈德巴赫”（不包括标点符号）和“陶”。
当总和小于5个质数时（即始终），打印零（16 = 0+0+0+3+13）
从标准输入中读取数字：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));
}

旧版本（179个字符），只能找到恰好5个素数的总和（因此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));
}

说明：
c设置*b为下一个素数（*b如果是素数则包括自身）。
T构建一个for循环，该循环将其中一个变量前进G,o,l,d,a到下一个素数。
在所有for循环中，我们检查总和是否匹配，如果匹配，则打印并退出。

Brachylog，9个字节

~+.ṗᵐl≤5∧

在线尝试！

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

红宝石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(<number>)。样本输出：

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

测试：http：//ideone.com/rua7A

的PHP 143122-8 = 114

编辑：在输出上保存了几个字节，删除了显式函数调用。

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

展开：

<?
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(<number>);Sample输出调用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字节-8 = 58

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

很大程度上基于GolfWolf的答案，但是由于它已经6岁了，所以我将发布自己的内容，而不是挑剔。技术的进步包括稳定的lambda，reduce而不是inject免费使用d，一种在5的分区处停止的简洁方法，并且Prime.each(o)在小于或等于o（并提供ach）的所有素数上进行迭代。也许再过六年，会有一种更好的使用方式b。

斯卡拉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)}}

在Bootyby提示之后：消除了一个函数调用，允许将3解释为3的和，而不是从输出中除去输入-节省另外20个字符。

奖金强调：

def g（o：Int）= {val l = 0 + :( 2至o）.filterNot（d =>（2至d-1）.exists（d％_ == 0））for（b <-l ; a <-l; c <-l; h <-l; e <-l; if（b + a + c + h + e == o））产量{（b，a，c，h，e） }}

调用和结果：

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

输出对每个列表重复x以求和x，然后显示5个求和。0为缺少的求和号，即2 + 2 + 13。

取消高尔夫：

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

此版本还将打印每个解决方案的所有排列：

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

是的，它创建了一个太长的list g。谁在乎？:-)

非高尔夫版本：

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个字节（但很慢-需要咨询）

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

在线尝试！

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

如果您有任何想法可以使其更快和更短，请告诉我！