Terence Tao ได้พิสูจน์รูปแบบการคาดเดาที่อ่อนแอของ Goldbach! ลองใช้ประโยชน์จากมัน!

รับจำนวนเต็มคี่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 จำนวนเต็มเป็น input nและส่งกลับรายการของจำนวนเต็มเป็นเอาท์พุทที่มีผลรวมเป็น ตามทฤษฏีของ Tao สิ่งนี้จะยุติลงเสมอ!

อินพุต

nเลขคี่ คุณตัดสินใจเลือกวิธีป้อนข้อมูล แต่ถ้าเป็นเรื่องแปลกให้อธิบาย

เอาท์พุต

ค่อนข้างปลายเปิด ส่งคืนรายการ พิมพ์สตริง เข้าใจอย่างใดอย่างหนึ่งไม่กี่หรือทั้งหมด ปล่อยให้อึวางลงบนกองซ้อน (GS, Piet, ฯลฯ ) หรือในบล็อกหน่วยความจำ (BF ที่สามารถเข้าถึงได้) ติดต่อกัน (เข้าถึงได้) ในลักษณะที่คาดการณ์ได้ สำหรับกรณีต่อไปนี้ให้อธิบายผลลัพธ์ ในทุกกรณีสิ่งที่คุณส่งคืน / พิมพ์ / whathaveyou คุณควรจะเป็นตัวแทนของตรงไปตรงมาของพาร์ติชันของnในช่วงเวลาที่มีน้อยกว่า 6 ส่วน

เกณฑ์การให้คะแนน

นี่คือรหัสกอล์ฟการนับจำนวนไบต์ที่น้อยที่สุดชนะ

โบนัส! หากคำว่า 'goldbach' ปรากฏขึ้นเป็นลำดับ (ไม่จำเป็นต้องต่อเนื่องกันตามลำดับกรณีไม่สำคัญ) ของโปรแกรมของคุณลบ 8 คะแนน โค้ดด้านบนเป็นตัวอย่างของสิ่งนี้

J , 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 ตัวอักษร

มี "Goldbach" ติดต่อกัน (ไม่รวมเครื่องหมายวรรคตอน) และ "เต่า" เช่นกัน
เมื่อรวมเป็นน้อยกว่า 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สร้างห่วงสำหรับซึ่งก้าวหน้าหนึ่งในตัวแปรG,o,l,d,aที่สำคัญต่อไป
ภายในลูปทั้งหมดเราจะตรวจสอบว่าผลรวมตรงกันหรือไม่และพิมพ์ & ออกหากทำได้

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 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 bytes - 8 = 58

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

หนักขึ้นอยู่กับคำตอบของ GolfWolf แต่เนื่องจากอายุ 6 ปีฉันจะโพสต์ของตัวเองแทนการ nitpicking ความก้าวหน้าทางเทคโนโลยีรวมถึงแลมบ์ดา (stabby แลมบ์ดา) 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)}}

หลังจากคำแนะนำของ Boothby: กำจัดการเรียกใช้ฟังก์ชันหนึ่งอนุญาตให้ตีความ 3 เป็นผลรวมของ 3 และไม่มีอะไรให้ลบอินพุตจากเอาต์พุต - บันทึกอีก 20 ตัวอักษร

โบนัสที่เน้น:

def g (o : Int) = {val l = 0 + :( 2 ถึง o) .filterNot ( d => (2 ถึง d-1) .exists (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!

หากคุณมีความคิดใด ๆ ที่จะทำให้เร็วขึ้นและสั้นลงโปรดแจ้งให้เราทราบ!