Terence Tao a récemment démontré une forme faible de conjecture de Goldbach! Exploitons-le!

Étant donné un entier impair n > 1, écrivez ncomme une somme de 5 nombres premiers. Prenez l'entrée comme bon vous semble et donnez la sortie comme bon vous semble. Par exemple,

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

est un code Sage qui prend un entier en entrée et renvoie une liste d'entiers en sortie dont la somme est n. Selon le théorème de Tao, cela se terminera toujours!

Contribution

Un entier impair n. Vous décidez comment prendre l'entrée, mais si c'est bizarre, expliquez-le.

Production

Plutôt ouvert. Renvoyez une liste. Imprime une chaîne. Donne-moi un, quelques-uns ou tous. Laissez les conneries traîner sur la pile (GS, Piet, etc.) ou dans un bloc de mémoire consécutif (accessible) (BF, etc.) de manière prévisible. Pour ces derniers cas, expliquez la sortie. Dans tous les cas, ce que vous retournez / imprimez / quoi doit être une représentation simple d'une partition de nen nombres premiers avec moins de 6 parties.

Notation

C'est le golf de code, le plus petit nombre d'octets gagne.

Prime! si le mot «goldbach» apparaît comme une sous-séquence (pas nécessairement consécutive; juste en ordre. La casse n'a pas d'importance) de votre programme, soustrayez 8 points. Le code ci-dessus en est un exemple.

J , 29

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

Suppose que l'entrée est en y. Valeur d'expression est la liste des boîtes de liste des 5 nombres premiers ou 0 cette somme 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 ...
+ ---------- + ---------- + ---------- + ---------- + ----- ----- + --------- + ---------- + ---------- + ---------- + - --------- + ---------- + ---------- + ---------- + ------- - + --------- + ---------- + ---------- + ---------- + ---- ------ + ---------- + ---------- + ---------- + --------- + ------...

Pas assez de lettres pour gagner des points bonus.

Mathematica , 38

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

C, 192-8 = 184 caractères

Contient "Goldbach" consécutivement (hors ponctuation) et "Tao" également.
Lorsque la somme est inférieure à 5 nombres premiers (ie toujours), des zéros imprime (16 = 0+0+0+3+13)
Lire le nombre d'entrée standard: 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));
}

Ancienne version (179 caractères), qui ne peut trouver que des sommes d'exactement 5 nombres premiers (et échoue donc pour 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));
}

Explication:
c définit *ble premier nombre premier (y compris *blui-même s'il est premier).
Tconstruit une boucle for, qui avance l'une des variables G,o,l,d,aau nombre premier suivant.
Dans toutes les boucles, nous vérifions si la somme correspond, et imprimons et quittons si c'est le cas.

Brachylog , 9 octets

~+.ṗᵐl≤5∧

Essayez-le en ligne!

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

Rubis 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

Appeler avec g(<number>) . Exemple de sortie:

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

Test: http://ideone.com/rua7A

PHP 143 122 - 8 = 114

EDIT: enregistré quelques octets en sortie, supprimé l'appel de fonction explicite.

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

Déroulé:

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

Appelez avec un @g(<number>);exemple de sortie pour 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 octets - 8 = 58

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

Fortement basé sur la réponse de GolfWolf, mais depuis qu'il a 6 ans, je vais poster le mien au lieu de tergiverser. Les progrès technologiques incluent le stabby lambda, utilisant reduceau lieu de injectgratuitement d, une manière laconique de s'arrêter à des partitions de 5, et Prime.each(o), qui itère sur tous les nombres premiers inférieurs ou égaux à o(et fournit un ach). Peut-être que dans 6 ans, il y aura une meilleure façon d'utiliser le 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)}}

Après le conseil de Boothby: éliminé un appel de fonction, permet d'interpréter 3 comme la somme de 3 et rien, supprime l'entrée de la sortie - enregistre 20 autres caractères.

Bonus mettant l'accent sur:

def g (o : Int) = {val l = 0 + :( 2 à o) .filterNot ( d => (2 à d-1) .existe (d% _ == 0)) pour (b <-l ; a <-l; c <-l; h <-l; e <-l; si (b + a + c + h + e == o)) donne {( b, a, c, h , e) }}

Invocation et résultat:

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

La sortie répète x pour chaque liste pour résumer à x, puis affiche les 5 sommets. 0 pour summand manquant, soit 2 + 2 + 13.

Non golfé:

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

Cette version imprimera également toutes les permutations de chaque solution:

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

Et oui, cela crée une liste beaucoup trop longue g. On s'en fout? :-)

Version non golfée:

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

Gelée , 19 octets (mais très lente - avis demandé)

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

Essayez-le en ligne!

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

Si vous avez des idées pour le rendre plus rapide et plus court, faites-le moi savoir!