Terence Tao kısa bir süre önce Goldbach'ın varsayımının zayıf olduğunu kanıtladı ! Hadi sömürelim!

Tek bir tamsayı verildiğinde n > 1, n5 astara kadar toplam olarak yazın. Girişi istediğiniz gibi alın ve istediğiniz gibi çıktı verin. Örneğin,

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

bir tamsayıyı girdi olarak alan ve toplamı çıktı olarak bir tamsayı listesi döndüren Adaçayı kodudur n. Tao'nun teoremi ile bu her zaman sona erecek!

Giriş

Garip bir tam sayı n. Girişi nasıl alacağınıza siz karar verirsiniz, ancak garip ise açıklayınız.

Çıktı

Oldukça açık uçlu. Bir liste döndür. Bir dize yazdırın. Bana bir, birkaç tane ya da hepsini ver. Bok yığınında (GS, Piet, vb.) Veya ardışık (ulaşılabilir) bir bellek bloğunda (BF, vb.) Bu sonraki durumlar için çıktıyı açıklayın. Her durumda, iade ettiğiniz / yazdırdığınız / ne yaptığınız n6 bölümden az olan primerlere bir bölümün basit bir temsili olmalıdır .

puanlama

Bu kod golf, en küçük bayt sayısı kazanır.

Bonus! Eğer 'goldbach' kelimesi bir program olarak görünüyorsa (ardışık olmak zorunda değil; sadece sırayla. Durum önemli değil) programınızın 8 puanını çıkarır. Yukarıdaki kod buna bir örnektir.

J , 29

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

Girdinin var olduğunu varsayar y. İfade değeri, toplamı 5 olan veya 0 olan liste kutularının listesidir y.

   y =. 16
   (# ~ y = + / @>), {5 $ <0, s: i._1 s:>: 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 ...
+ ---------- + ---------- + ---------- + ---------- + ----- ----- + --------- + ---------- + ---------- + ---------- + - --------- + ---------- + ---------- + ---------- + ------- - + --------- + ---------- + ---------- + ---------- + ---- ------ + ---------- + ---------- + ---------- + --------- + ------...

Herhangi bir bonus puan kazanmak için yeterli harf yok.

Mathematica , 38

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

C, 192-8 = 184 karakter

Ard arda "Goldbach" (noktalama işaretleri hariç) ve "Tao" içerir.
Toplamı 5'ten az asal (örneğin, her zaman), baskı sıfır (16 = olduğunda 0+0+0+3+13)
standart giriş numarası okuyun 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));
}

Sadece tam 5 asalın toplamını bulabilen (ve bu nedenle x <10 için başarısız olan) eski sürüm (179 karakter):

#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));
}

Açıklama:
c*b sonraki asal olarak ayarlanır (asal *bise kendisi dahil ).
TDeğişkenlerden birini bir G,o,l,d,asonraki prime ilerleten bir for döngüsü oluşturur .
İçinde döngüler için toplamın eşleşip eşleşmediğini kontrol eder ve varsa yazdırır ve çıkar.

Brachylog , 9 bayt

~+.ṗᵐl≤5∧

Çevrimiçi deneyin!

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

Yakut 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

İle arayın g(<number>). Örnek çıktı:

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

Test: http://ideone.com/rua7A

PHP 143 - 8 = 114

DÜZENLEME: Çıktıda birkaç bayt kaydedildi, açık işlev çağrısı kaldırıldı.

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

unrolled:

<?
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>);Örnek çıktı ile aşağıdakileri arayın 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

Yakut 2 -rmathn, 66 bayt - 8 = 58

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

GolfWolf'un cevabına yoğun olarak dayanıyor, ancak 6 yaşından beri nitpicking yerine kendi mesajımı göndereceğim. Teknolojideki ilerlemeler arasında , serbest reduceyerine kullanmak injectiçin kullanılan 5'lik dbölümlerde durmanın kısa bir yolunu kullanan ve Prime.each(o)tüm eşitliklere eşit veya daha küçük o(ve bir ach) sağlayan tekrarlayan lambda bulunmaktadır . Belki başka bir 6 yıl içinde kullanmak için daha iyi bir yol olacaktır 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)}}

Boothby'nin ipucundan sonra: bir işlev çağrısını ortadan kaldırın, 3'ü 3 ve hiçbir şeyin toplamı olarak yorumlamaya izin verin, girdiyi çıktıdan çıkarın - 20 karakter daha kaydeder.

Bonus vurgusu:

def g (o : Int) = {val l = 0 + :( 2 ila o) .filterNot ( d => (2 ila d-1). var (d% _ == 0)) için (b <-l ; a <-l; c <-l; h <-l; e <-l; eğer (b + a + c + h + e == o)) verim {( b, a, c, h , e) }}

Çağrı ve sonuç:

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

Çıktı, her liste için x değerine kadar x değerini tekrarlar ve ardından 5 toplamı gösterir. Eksik toplam için 0, yani 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)))))

Bu sürüm ayrıca her çözümün tüm permütasyonlarını yazdıracaktır:

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

Ve evet, çok uzun bir liste yaratıyor g. Kimin umrunda? :-)

Ungolfed sürümü:

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

Jöle , 19 bayt (ama çok yavaş - tavsiye istedim)

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

Çevrimiçi deneyin!

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

Daha hızlı ve daha kısa yapmak için herhangi bir fikriniz varsa, lütfen bana bildirin!