Giả thuyết Goldbach nói rằng mọi số chẵn lớn hơn hai có thể được biểu diễn dưới dạng tổng của hai số nguyên tố. Ví dụ,

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

Tuy nhiên, một khi chúng ta nhận được đến 10 điều thú vị xảy ra. 10 không chỉ có thể được viết là

5 + 5

nhưng nó cũng có thể được viết là

7 + 3

Vì 10 có thể được biểu thị bằng tổng của hai số nguyên tố theo hai cách , nên chúng tôi nói rằng "phân vùng Goldbach" của 10 là 2. Hay nói chung hơn,

Phân vùng Goldbach của một số là tổng số cách viết khác nhau ở n = p + qđâu pvà qlà số nguyên tố vàp >= q

Thử thách của bạn là viết một chương trình hoặc hàm tìm phân vùng Goldbach của một số. Bây giờ, về mặt kỹ thuật thuật ngữ "phân vùng Goldbach" chỉ được sử dụng để chỉ các số chẵn. Tuy nhiên, vì số nguyên lẻ p + 2 cũng có thể được biểu diễn dưới dạng tổng của hai số nguyên tố nếu p> 2 là số nguyên tố, chúng tôi sẽ mở rộng số này cho tất cả các số nguyên dương ( A061353 ).

Bạn có thể giả định một cách an toàn rằng đầu vào của bạn sẽ luôn là số nguyên dương và bạn có thể lấy đầu vào và đầu ra trong bất kỳ phương thức được phép mặc định nào của chúng tôi , ví dụ: đối số hàm và giá trị trả về, STDIN và STDOUT, đọc và ghi vào tệp, v.v.

Các phân vùng Goldbach của các số nguyên dương lên tới 100 là:

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

Như thường lệ, các sơ hở tiêu chuẩn được áp dụng và câu trả lời ngắn nhất tính theo byte sẽ thắng!

Thạch , 8 byte

_ÆRÆPSHĊ

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

_Æ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 byte

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)

Thu thập đệ quy từ k=2đến n/2, thêm các giá trị trong đó cả hai kvà n-klà số nguyên tố. nThay vào đó, thật tốt khi đếm ngược cùng một lúc, nhưng điều này có một vấn đề k=0và k=1được gọi sai là số nguyên tố:

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)

Kiểm tra tính nguyên thủy là phân chia thử nghiệm, rút ​​ngắn bằng cách kiểm tra cả hai kvà n-kcùng nhau. Tôi thấy điều này ngắn hơn so với sử dụng trình tạo Định lý Wilson (79 byte):

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

Ý tưởng cho điều này là giữ một danh sách tất cả các số nguyên tố ở nửa dưới để được kiểm tra khi chúng ta đến nửa trên, nhưng đối với điểm giữa k=n/2, chúng ta không có thời gian để thêm n-kvào danh sách khi chúng ta đến k. Một phiên bản lặp đi lặp lại xung quanh điều này, nhưng là 82 byte:

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

TOÁN , 8 byte

tZq&+=Rz

Hãy thử trực tuyến!

Giải trình

Hãy xem xét đầu vào 8như một ví dụ

      % 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

Thật thú vị khi quan sát biểu đồ của chuỗi , sử dụng phiên bản mã được sửa đổi một chút:

:"@       % 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

Đối với đầu vào 10000, kết quả là

Bạn có thể dùng thử tại MATL Online (Làm mới trang nếu nút "Chạy" không thay đổi thành "Giết" khi nhấn). Phải mất khoảng 25 giây để tạo ra biểu đồ cho đầu vào 3000; đầu vào trên một vài ngàn sẽ hết thời gian.

JavaScript (ES6), 77 73 70 byte

Đã lưu 3 byte nhờ @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

flà một chức năng kiểm tra nguyên thủy; chức năng liên quan làg .

fhoạt động bằng cách đếm ngược đệ quy từ n-1 ; dòng điều khiển ở mỗi giai đoạn diễn ra như sau:

• x<2||Nếu x <2 , số là số nguyên tố; trở về 1 .
• n%x&&Mặt khác, nếu n mod x = 0 , số không phải là số nguyên tố; trở vền%x .
• f(n,x-1)Mặt khác, số có thể hoặc không phải là số nguyên tố; giảm x và thử lại.

ghoạt động theo cách tương tự, mặc dù không có quá nhiều luồng điều khiển. Nó hoạt động bằng cách nhân f (b) với f (ab) cho mỗi số nguyên b trong phạm vi [2, sàn (a / 2)] , sau đó tổng hợp kết quả. Điều này cho chúng ta số lượng cặp tổng hợp thành một trong đó cả hai số trong cặp là số nguyên tố, đó chính xác là những gì chúng ta muốn.

05AB1E , 10 8 byte

Vô cùng kém hiệu quả.

D!f-pO;î

Hãy thử trực tuyến! hoặc là Thử một cách ít hiệu quả hơn để tạo các số nguyên tố

Giải trình

n = 10 dùng làm ví dụ.

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 byte

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

Tôi không nghĩ GAP có cách ngắn hơn cách rõ ràng này. Numberđếm có bao nhiêu yếu tố của một danh sách thỏa mãn một vị ngữ.

Sử dụng nó để tính 100 giá trị đầu tiên:

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 byte

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

Hãy thử trực tuyến!

Giải trình

Một phiên âm thẳng lên của vấn đề.

:{                }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

Toán học, 52 byte

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

Kết quả được cung cấp như một chức năng ẩn danh. Cố gắng vẽ đồ thị trên nó:

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

Nhân tiện, mã có cùng độ dài với phiên bản chức năng của mã demo trên OEIS.

Thạch , 12 byte

HRð,_@ÆPð×/S

Dùng thử
1-100

Làm sao?

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

Vợt 219 byte

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

Ung dung:

(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

Kiểm tra:

(f 10)
(f 100)

Đầu ra:

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

Trên thực tế , 11 byte

;R`p`░@-♂bΣ

Hãy thử trực tuyến!

Giải trình:

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

05AB1E , 6 byte

;ÅP-pO

Hãy thử trực tuyến!

Giải trình:

                  # 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 byte

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]

Ví dụ sử dụng: 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].

Thực hiện trực tiếp của định nghĩa: bind đầu tiên rcho tất cả các số nguyên tố lên đến số lượng đầu vào n, sau đó hãy 1cho tất cả pvà qtừ rnơi q<=pvà p+q==nvà tổng hợp chúng.