การคาดคะเนของ Goldbachระบุว่าจำนวนที่มากกว่าสองจะแสดงเป็นผลรวมของสองช่วง ตัวอย่างเช่น,

4 = 2 + 2
6 = 3 + 3
8 = 5 + 3

อย่างไรก็ตามเมื่อเราไปถึง 10 สิ่งที่น่าสนใจเกิดขึ้น สามารถเขียนเป็น 10 เท่านั้นไม่ได้

5 + 5

แต่มันก็สามารถเขียนเป็น

7 + 3

ตั้งแต่วันที่ 10 สามารถแสดงเป็นผลรวมของสองจำนวนเฉพาะสองวิธีที่เราบอกว่า "Goldbach พาร์ทิชัน" ของ 210 หรือมากกว่าโดยทั่วไป

พาร์ทิชัน Goldbach ของจำนวนคือจำนวนรวมของวิธีการเขียนn = p + qที่แตกต่างกันที่ไหนpและqเป็นช่วงเวลาและp >= q

ความท้าทายของคุณคือการเขียนโปรแกรมหรือฟังก์ชั่นที่พบพาร์ติชัน Goldbach ของตัวเลข ตอนนี้ในทางเทคนิคแล้วคำว่า "พาร์ทิชัน Goldbach" ใช้เพื่ออ้างถึงตัวเลขคู่เท่านั้น อย่างไรก็ตามเนื่องจากเป็นจำนวนเต็มคี่P + 2สามารถยังจะแสดงเป็นผลรวมของสองจำนวนเฉพาะถ้าp> 2เป็นสำคัญเราจะขยายนี้เพื่อจำนวนเต็มบวกทั้งหมด ( A061358 )

คุณอาจสันนิษฐานได้ว่าข้อมูลที่ป้อนของคุณจะเป็นจำนวนเต็มบวกเสมอและคุณสามารถนำเข้าและส่งออกในวิธีการเริ่มต้นที่เราอนุญาตเช่นอาร์กิวเมนต์ฟังก์ชันและค่าส่งคืน STDIN และ STDOUT การอ่านและการเขียนลงไฟล์ ฯลฯ

พาร์ทิชัน Goldbach ของจำนวนเต็มบวกถึง 100 คือ:

0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 0, 1, 1, 2, 1, 2, 0, 2, 1, 2, 1, 3, 0, 3, 1,
3, 0, 2, 0, 3, 1, 2, 1, 4, 0, 4, 0, 2, 1, 3, 0, 4, 1, 3, 1, 4, 0, 5, 1, 4,
0, 3, 0, 5, 1, 3, 0, 4, 0, 6, 1, 3, 1, 5, 0, 6, 0, 2, 1, 5, 0, 6, 1, 5, 1,
5, 0, 7, 0, 4, 1, 5, 0, 8, 1, 5, 0, 4, 0, 9, 1, 4, 0, 5, 0, 7, 0, 3, 1, 6

ตามปกติจะใช้ช่องโหว่มาตรฐานและคำตอบที่สั้นที่สุดเป็นไบต์จะชนะ!

เยลลี่ขนาด 8 ไบต์

_ÆRÆPSHĊ

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

มันทำงานอย่างไร

_ÆRÆPSHĊ  Main link. Argument: n (positive integer)

 ÆR       Prime range; yield [2, 3, 5, ..., n].
_         Subtract all primes in this range from n.
   ÆP     Compute the primality of the resulting differences.
          This returns 1 for each prime p such that n - p is also prime.
     S    Compute the sum of the resulting Booleans.
      H   Divide it by 2, since [p, n - p] and [n - p, p] have both been counted.
       Ċ  Ceil; round the resulting quotient up (needed if n = 2p).

Python 2, 76 ไบต์

g=lambda n,k=2:n/k/2and all(x%i for x in[k,n-k]for i in range(2,x))+g(n,k+1)

รวบรวมข้อมูลซ้ำ ๆ ซ้ำ ๆ จากk=2เป็นn/2เพิ่มค่าที่ทั้งสองkและn-kสำคัญ มันจะดีที่จะนับnลงในเวลาเดียวกันแทน แต่ตอนนี้มีปัญหาว่าk=0และk=1จะเรียกว่าตู่สำคัญ:

g=lambda n,k=0:n/k and all(x%i for x in[k,n]for i in range(2,x))+g(n-1,k+1)

การตรวจสอบเบื้องต้นคือการแบ่งการทดลองสั้นลงโดยการตรวจสอบทั้งสองkและn-kร่วมกัน ฉันพบสิ่งนี้จะสั้นกว่าการใช้เครื่องกำเนิดทฤษฎีบทของ Wilson (79 ไบต์):

f=lambda n,k=1,P=1,l=[]:n/k and P%k*(n-k in l+P%k*[k])+f(n,k+1,P*k*k,l+P%k*[k])

แนวคิดสำหรับอันนี้คือการเก็บรายการของช่วงเวลาทั้งหมดไว้ในครึ่งล่างเพื่อตรวจสอบตามเวลาที่เราไปถึงครึ่งบน แต่สำหรับจุดกึ่งกลาง k=n/2เรายังไม่มีเวลาเพิ่มn-kรายการออกเมื่อเราไปถึงk. เวอร์ชันที่ซ้ำ ๆ จะอยู่ที่นี่ แต่มีขนาด 82 ไบต์:

n=input()
s=P=k=1;l=[]
while k<n:l+=P%k*[k];s+=P%k*(n-k in l);P*=k*k;k+=1
print~-s

MATL , 8 ไบต์

tZq&+=Rz

ลองออนไลน์!

คำอธิบาย

พิจารณาการป้อนข้อมูล8เป็นตัวอย่าง

      % Take input implicitly
t     % Duplicate
      % STACK: 8, 8
Zq    % All primes up to that number
      % STACK: 8, [2 3 5 7]
&+    % Matrix with all pairwise additions
      % STACK: 8, [4  5  7  9
                   5  6  8 10
                   7  8 10 12
                   9 10 12 14]
=     % True for entries that equal the input
      % STACK: [0 0 0 0
                0 0 1 0
                0 1 0 0
                0 0 0 0]
R     % Extract upper triangular part (including diagonal). 
      % This removes pairs that are equal up to order
      % STACK: [0 0 0 0
                0 0 1 0
                0 0 0 0
                0 0 0 0]
z     % Number of nonzero entries
      % STACK: 1
      % Display implicitly

มันน่าสนใจที่จะสังเกตกราฟของลำดับโดยใช้โค้ดที่แก้ไขเล็กน้อย:

:"@       % Input n implicitly. For each k from 1 to n, push k
tZq&+=Rz  % Same code as above. Pushes the result for each k
]v'.'&XG  % End. Concatenate all results into a vector. Plot as dots

สำหรับอินพุต10000ผลลัพธ์คือ

คุณสามารถลองได้ที่MATL Online (รีเฟรชหน้าหากปุ่ม "Run" ไม่เปลี่ยนเป็น "Kill" เมื่อกด) มันต้องใช้เวลาหลายประการเกี่ยวกับ 25 วินาทีในการผลิตกราฟสำหรับการป้อนข้อมูล3000; อินพุตเกินสองสามพันจะหมดเวลา

JavaScript (ES6), 77 73 70 ไบต์

บันทึกแล้ว 3 ไบต์ขอบคุณ @Arnauld

f=(n,x=n)=>--x<2||n%x&&f(n,x)
g=(a,b=a>>1)=>b>1?f(b)*f(a-b)+g(a,b-1):0

fเป็นฟังก์ชั่นทดสอบดั้งเดิม gฟังก์ชั่นที่เกี่ยวข้องคือ

fทำงานโดยการนับซ้ำจากn-1ซ้ำๆ การควบคุมการไหลในแต่ละขั้นตอนจะเป็นดังนี้:

• x<2||ถ้าx <2จำนวนนั้นเป็นจำนวนเฉพาะ กลับ1
• n%x&&มิฉะนั้นถ้าn mod x = 0จำนวนจะไม่เป็นไพร์ม; n%xกลับ
• f(n,x-1)มิฉะนั้นตัวเลขอาจจะใช่หรือไม่ใช่นายกรัฐมนตรี ลดค่าxและลองอีกครั้ง

gทำงานในลักษณะที่คล้ายกัน แต่มีกระแสการควบคุมไม่มาก มันทำงานโดยการคูณf (b)โดยf (ab)สำหรับแต่ละจำนวนเต็มbในช่วง[2, floor (a / 2)]แล้วสรุปผล นี้จะช่วยให้เราจำนวนคู่ที่รวมไปที่ตัวเลขทั้งคู่มีความสำคัญซึ่งเป็นสิ่งที่เราต้องการ

05AB1E , 10 8 ไบต์

ไม่มีประสิทธิภาพมาก

D!f-pO;î

ลองออนไลน์! หรือลองวิธีที่มีประสิทธิภาพน้อยกว่าในการสร้างช่วงเวลา

คำอธิบาย

n = 10 ใช้เป็นตัวอย่าง

D          # duplicate
           # STACK: 10, 10 
 !         # factorial
           # STACK: 10, 3628800
  f        # unique prime factors
           # STACK: 10, [2,3,5,7]
   -       # subtract
           # STACK: [8,7,5,3]
    p      # is prime
           # STACK: [0,1,1,1]
     O     # sum
           # STACK: 3
      ;    # divide by 2
           # STACK: 1.5
       î   # round up
           # STACK: 2
           # implicit output

GAP , 57 ไบต์

n->Number([2..QuoInt(n,2)],k->IsPrime(k)and IsPrime(n-k))

ฉันไม่คิดว่า GAP มีวิธีที่สั้นกว่าอันนี้ชัดเจน Numberนับจำนวนองค์ประกอบของรายการที่ตอบสนองกริยา

ใช้เพื่อคำนวณ 100 ค่าแรก:

gap> List([1..100],n->Number([2..QuoInt(n,2)],k->IsPrime(k)and IsPrime(n-k)));
[ 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 0, 1, 1, 2, 1, 2, 0, 2, 1, 2, 1, 3, 0, 3, 1, 
  3, 0, 2, 0, 3, 1, 2, 1, 4, 0, 4, 0, 2, 1, 3, 0, 4, 1, 3, 1, 4, 0, 5, 1, 4, 
  0, 3, 0, 5, 1, 3, 0, 4, 0, 6, 1, 3, 1, 5, 0, 6, 0, 2, 1, 5, 0, 6, 1, 5, 1, 
  5, 0, 7, 0, 4, 1, 5, 0, 8, 1, 5, 0, 4, 0, 9, 1, 4, 0, 5, 0, 7, 0, 3, 1, 6 ]

Brachylogขนาด 22 ไบต์

:{,A:B>=.:#pa+?,.=}fl

ลองออนไลน์!

คำอธิบาย

การถอดความปัญหาอย่างตรงไปตรงมา

:{                }f       Find all valid outputs of the predicate in brackets for the Input
                    l      Output is the number of valid outputs found

  ,A:B>=.                  Output = [A, B] with A >= B
         :#pa              Both A and B must be prime numbers
             +?,           The sum of A and B is the Input
                .=         Label A and B as integers that verify those constraints

Mathematica, 52 ไบต์

Count[IntegerPartitions[#,{2}]//PrimeQ,{True,True}]&

ผลลัพธ์ถูกจัดเตรียมเป็นฟังก์ชันที่ไม่ระบุตัวตน ลองพล็อตกราฟเหนือกราฟ:

DiscretePlot[
 Count[IntegerPartitions[#, {2}] // PrimeQ, {True, True}] &[i], {i, 1,
   1000}]

อย่างไรก็ตามโค้ดนั้นมีความยาวเท่ากันกับเวอร์ชั่นฟังก์ชั่นของโค้ดตัวอย่างบน OEIS

เยลลี่ 12 ไบต์

HRð,_@ÆPð×/S

TryItOnline
1-100

อย่างไร?

HRð,_@ÆPð×/S - Main link: n    e.g. 22
H            - halve
 R           - range          [1,2,3,4,5,6,7,8,9,10,11] (note this will be 1 to n//2)
  ð          - dyadic chain separation
   ,         - pair with
    _@       - n -           [[1,2,3,4,5,6,7,8,9,10,11],[21,20,19,18,17,16,15,14,13,12,11]]
      ÆP     - is prime? (1 if prime 0 if not)
                            [[0,1,1,0,1,0,1,0,0,0,1],[0,0,1,0,1,0,0,0,1,0,1]]
        ð    - dyadic chain separation
         ×/  - reduce with multiplication
                             [0,0,1,0,1,0,0,0,0,0,1]
           S - sum           3

แร็กเก็ต 219 ไบต์

(let*((pl(for/list((i n) #:when(prime? i))i))(ll(combinations(append pl pl)2))(ol'()))(for/list((i ll))(define tl(sort i >))
(when(and(= n(apply + i))(not(ormap(λ(x)(equal? x tl))ol)))(set! ol(cons tl ol))))(length ol))

Ungolfed:

(define(f n)
 (let* ((pl                                   ; create a list of primes till n
          (for/list ((i n) #:when (prime? i))
            i))
         (ll (combinations (append pl pl) 2)) ; get a list of combinations of 2 primes
         (ol '()))                            ; initialize output list
    (for/list ((i ll))                        ; test each combination
      (define tl (sort i >))
      (when (and (= n (apply + i))            ; sum is n
                 (not(ormap (lambda(x)(equal? x tl)) ol))) ; not already in list
        (set! ol (cons tl ol))))              ; if ok, add to list
    (println ol)                              ; print list
    (length ol)))                             ; print length of list

การทดสอบ:

(f 10)
(f 100)

เอาท์พุท:

'((5 5) (7 3))
2
'((97 3) (89 11) (83 17) (71 29) (59 41) (53 47))
6

ที่จริงแล้ว 11 ไบต์

;R`p`░@-♂bΣ

ลองออนไลน์!

คำอธิบาย:

;R`p`░@-♂bΣ
 R`p`░       prime values in [1, n]
;     @-     subtract each value from n
        ♂b   convert each value to boolean
          Σ  sum

05AB1E , 6 ไบต์

;ÅP-pO

ลองออนไลน์!

คำอธิบาย:

                  # implicit input (example: 10)
;                 # divide input by 2 (5)
 ÅP               # primes up to that ([2, 3, 5])
   -              # subtract from the implict input ([8, 7, 5])
    p             # isPrime? ([0, 1, 1])
     O            # sum (2), implicit output

Haskell, 73 ไบต์

f n|r<-[a|a<-[2..n],all((<2).gcd a)[2..a-1]]=sum[1|p<-r,q<-r,q<=p,p+q==n]

ตัวอย่างการใช้งาน: ->map f [1..25][0,0,0,1,1,1,1,1,1,2,0,1,1,2,1,2,0,2,1,2,1,3,0,3,1]

การดำเนินงานโดยตรงของคำนิยาม: ผูกเป็นครั้งแรกrที่จะเฉพาะทั้งหมดขึ้นอยู่กับจำนวนการป้อนข้อมูลnแล้วใช้1ทั้งหมดpและqจากrที่q<=pและp+q==nและรวมพวกเขา