Goldbach의 추측에 따르면 2보다 큰 짝수는 두 소수의 합으로 표현할 수 있습니다. 예를 들어

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

그러나 일단 10에 도달하면 흥미로운 일이 발생합니다. 10은 다음과 같이 쓸 수 있습니다.

5 + 5

그러나 그것은 또한 다음과 같이 쓸 수 있습니다

7 + 3

10은 두 가지 소수의 두 가지 방법 의 합으로 표현 될 수 있으므로 10 의 "Goldbach partition"은 다음과 같습니다 2. 또는 더 일반적으로

다수의 골드 바흐 파티션이 글을 쓰는 독특한 방법의 총 수입니다 n = p + q곳 p과 q소수이며,p >= q

당신의 도전은 숫자의 Goldbach 파티션을 찾는 프로그램이나 함수를 작성하는 것입니다. 이제 기술적으로 "Goldbach 파티션"이라는 용어는 짝수를 나타내는 데만 사용됩니다. 그러나 p> 2 가 소수이면 홀수 정수 p + 2 도 두 소수의 합으로 표현 될 수 있으므로 모든 양의 정수로 확장합니다 ( A061358 ).

입력은 항상 양의 정수라고 안전하게 가정 할 수 있으며 함수 인수 및 반환 값, STDIN 및 STDOUT, 파일 읽기 및 쓰기 등과 같은 기본 허용 메소드 중 하나에서 입력 및 출력을 취할 수 있습니다 .

최대 100까지 양의 정수로 이루어진 Goldbach 파티션은 다음과 같습니다.

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

파이썬 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함께. 나는 이것이 윌슨 정리 생성기 (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

약간 수정 된 코드 버전을 사용하여 sequence 의 그래프 를 관찰하는 것이 흥미 롭습니다 .

:"@       % 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 에서 시도해 볼 수 있습니다 (눌렀을 때 "실행"버튼이 "킬"로 변경되지 않으면 페이지를 새로 고침). 입력 그래프를 생성하는 데 약 25 초가 소요됩니다 3000. 수천 개가 넘는 입력은 시간 초과됩니다.

자바 스크립트 (ES6), 77 73 70 바이트

@Arnauld 덕분에 3 바이트 절약

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입니다.

fn-1 부터 재귀 적으로 카운트 다운하여 작동합니다 . 각 단계에서의 제어 흐름은 다음과 같습니다.

• x<2||만약 X <2 , 수 소수; 1을 반환 합니다.
• n%x&&그렇지 않으면 n mod x = 0 이면 숫자는 소수가 아닙니다. return n%x.
• f(n,x-1)그렇지 않으면 숫자가 소수 일 수도 있고 아닐 수도 있습니다. 감소 X 다시 시도하십시오.

g제어 흐름이 그리 많지는 않지만 비슷한 방식으로 작동합니다. [2, floor (a / 2)] 범위의 각 정수 b 에 대해 f (b) 에 f (ab) 를 곱한 다음 결과를 합산하여 작동합니다. 이것은 우리에게 쌍의 수를 제공하는 합이 쌍의 두 숫자는 우리가 원하는 정확히 무엇 인 프라임 있습니다.

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

간격 , 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

매스 매 티카, 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))

언 골프 드 :

(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

하스켈, 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이를 더할.