Нещодавно Теренс Тао виявив слабку форму здогадки Гольдбаха! Давайте експлуатувати це!

Давши непарне ціле число 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 частин.

Оцінка балів

Це кодовий гольф, найменший виграш байтів.

Бонус! якщо слово "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]

C, 192-8 = 184 знаків

Містить "Гольдбах" послідовно (крім пунктуації) та "Дао".
Коли сума менше 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до наступного простого.
Протягом усіх циклів ми перевіряємо, чи відповідає сума, і друкуємо та виходимо, якщо вона є.

Брахілог , 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

EDIT: Збережено кілька байтів на виході, видалено явний виклик функції.

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

Безголівки:

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

Якщо у вас є ідеї, щоб зробити це швидше і коротше, будь ласка, повідомте мене!