Теренс Тао недавно доказал слабую форму гипотезы Гольдбаха! Давайте использовать это!

Если дано нечетное целое число 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 и т. Д.) Предсказуемым образом. Для этих более поздних случаев объясните вывод. Во всех случаях то, что вы возвращаете / print / whathaveyou, должно быть простым представлением разбиения nна простые числа, состоящие менее чем из 6 частей.

счет

Это код гольф, выигрывает наименьшее количество байтов.

Бонус! если слово «goldbach» появляется как подпоследовательность (не обязательно последовательная; просто по порядку. Дело не имеет значения) вашей программы, отнимите 8 баллов. Код выше является примером этого.

J , 29

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

Предполагается, что вход находится в y. Значением выражения является список полей списка из 5 простых чисел или 0, сумма которых равна 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 ...
+ ---------- + ---------- + ---------- + ---------- + ----- ----- + --------- + ---------- + ---------- + ---------- + - --------- + ---------- + ---------- + ---------- + ------- - + --------- + ---------- + ---------- + ---------- + ---- ------ + ---------- + ---------- + ---------- + --------- + ------...

Недостаточно букв, чтобы заработать бонусные баллы.

Математика , 38

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

С 192-8 = 184 символа

Содержит "Goldbach" последовательно (исключая пунктуацию), а также "Дао".
Когда сумма меньше 5 простых чисел (т.е. всегда), печатает нули (16 = 0+0+0+3+13)
Read число из стандартного ввода: 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 мы проверяем, совпадает ли сумма, и печатаем и завершаем работу, если она совпадает.

Брахилог , 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 143 122 - 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>);примером вывода для 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 лет, я собираюсь опубликовать свое собственное, вместо придирки. Достижения в области технологий включают в себя стабильную лямбду, использующую reduceвместо injectбесплатного dкраткий способ остановки на разделах по 5, иPrime.each(o) который перебирает все простые числа, меньшие или равные o(и обеспечивающие ach). Возможно, через 6 лет появится лучший способ использования 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)}}

После подсказки Бутби: исключен один вызов функции, разрешено интерпретировать 3 как сумму 3 и ничего, удалить ввод из вывода - экономит еще 20 символов.

Бонус подчеркивающий:

def g (o : Int) = {val l = 0 + :( от 2 до o) .filterNot ( d => (от 2 до d-1). существует (d% _ == 0)) для (b <-l ; a <-l; c <-l; h <-l; e <-l; если (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.

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

Эта версия также напечатает все перестановки каждого решения:

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

И да, это создает слишком длинный список 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

Желе , 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!

Если у вас есть идеи, как сделать это быстрее и короче, пожалуйста, дайте мне знать!