Goldbach varsayımı ikiden büyük her çift sayısının iki asalın toplamı olarak ifade edilebileceğini belirtir. Örneğin,

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

Ancak, 10'a ulaştığımızda ilginç bir şey olur. Sadece 10 kişi yazılamaz

5 + 5

ama aynı zamanda şu şekilde de yazılabilir

7 + 3

10 iki asal sayının toplamı olarak ifade edilebilir yana iki yol , biz 10 "Goldbach bölüm" olduğunu söylemek 2. Veya daha genel olarak,

Bir sayının Goldbach bölümü, n = p + qnerede pve qasal olanlar olduğu toplam farklı yazma yollarının sayısıdır.p >= q

Zorluğunuz, bir sayının Goldbach bölümünü bulan bir program veya işlev yazmaktır. Şimdi, teknik olarak "Goldbach bölümü" terimi sadece çift sayıları ifade etmek için kullanılmaktadır. Tek tamsayı Ancak, p + 2 için , aynı zamanda , iki asal sayının toplamı olarak ifade edilebilir, eğer p> 2 asal olduğu için, tüm pozitif tamsayılar (bu uzatacaktır A061358 ).

Girişinizin her zaman pozitif bir tamsayı olacağını güvenli bir şekilde kabul edebilirsiniz ve örneğin, işlev argümanları ve dönüş değeri, STDIN ve STDOUT, bir dosyayı okuma ve yazma gibi varsayılan izin verilen yöntemlerden herhangi birinde giriş ve çıkış alabilirsiniz .

100'e kadar pozitif tamsayıların Goldbach bölümleri şunlardır:

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

Her zamanki gibi standart boşluklar uygulanır ve bayt cinsinden en kısa cevap kazanır!

Jöle , 8 bayt

_ÆRÆPSHĊ

Çevrimiçi deneyin! veya tüm test senaryolarını doğrulayın .

Nasıl çalışır

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

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)

Yinelemeli kadar tarar k=2için n/2her iki değerlerinin toplanması, kve n-kasal vardır. Bunun nyerine aynı anda geri saymak güzel olurdu , ancak bunun bir sorunu var k=0vek=1 asal olarak adlandırılan yanlış olarak adlandırılan :

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)

Asallık kontrol kontrol kısaltılabilir deneme bölme, hem kven-k birlikte. Ben bir Wilson Teoremi jeneratör (79 bayt) kullanmaktan daha kısa bulundu:

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

Bunun fikri, ilk yarıdaki tüm primerlerin bir listesini üst yarıya ulaştığımız k=n/2zamana kadar kontrol etmek, ancak orta nokta için , n-kulaştığımızda listeye eklemek için zamanımız olmadı . k. Yinelemeli bir sürüm bunun etrafında gider, ancak 82 bayttır:

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 bayt

tZq&+=Rz

Çevrimiçi deneyin!

açıklama

Girişi 8örnek olarak düşünün

      % 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

Kodun biraz değiştirilmiş bir sürümünü kullanarak dizinin grafiğini gözlemlemek ilginçtir :

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

Giriş 10000için sonuç

MATL Online'da deneyebilirsiniz ("Çalıştır" düğmesi basıldığında "Öldür" olarak değişmezse sayfayı yenileyin). Giriş için grafiğin üretilmesi yaklaşık 25 saniye sürer 3000; birkaç binin üzerindeki girdiler zaman aşımına uğrayacaktır.

JavaScript (ES6), 77 73 70 bayt

@Arnauld sayesinde 3 bayt kaydedildi

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

fbir öncelik testi fonksiyonudur; ilgili işlev g.

fn-1'den tekrar tekrar geri sayım yaparak çalışır ; her aşamadaki kontrol akışı şu şekildedir:

• x<2||Eğer x <2 , sayı asal; dönüş 1 .
• n%x&&Aksi takdirde, n mod x = 0 ise sayı asal değildir; dönüş n%x.
• f(n,x-1)Aksi takdirde, sayı asal olabilir veya olmayabilir; x değerini azaltın ve tekrar deneyin.

gçok fazla kontrol akışı olmasa da benzer bir şekilde çalışır. [2, kat (a / 2)] aralığındaki her bir tamsayı b için f (b) ile f (ab) çarparak ve ardından sonuçları toplayarak çalışır. Bu bize, çiftteki her iki sayının da asal olduğu bir yerde toplanan çiftlerin sayısını verir , bu da tam olarak istediğimiz şeydir.

05AB1E , 10 8 bayt

Son derece verimsiz.

D!f-pO;î

Çevrimiçi deneyin! veya Asal üretmenin daha az etkili bir yolunu deneyin

açıklama

n = 10 örnek olarak kullanılmıştır.

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 bayt

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

GAP'ın bu bariz olandan daha kısa bir yolu olduğunu düşünmüyorum. Numberbir listenin kaç öğesinin yüklemi karşıladığını sayar.

İlk 100 değeri hesaplamak için kullanma:

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 bayt

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

Çevrimiçi deneyin!

açıklama

Sorunun düz bir transkripsiyonu.

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

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

Sonuç anonim bir işlev olarak sağlanır. Üzerine bir grafik çizmeye çalışın:

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

Bu arada, kod OEIS'teki demo kodunun işlev sürümü ile aynı uzunlukta.

Jöle , 12 bayt

HRð,_@ÆPð×/S

TryItOnline
1-100

Nasıl?

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

Raket 219 bayt

(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

Test yapmak:

(f 10)
(f 100)

Çıktı:

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

Aslında 11 bayt

;R`p`░@-♂bΣ

Çevrimiçi deneyin!

Açıklama:

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

05AB1E , 6 bayt

;ÅP-pO

Çevrimiçi deneyin!

Açıklama:

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

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]

Kullanım örneği: 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].

Tanımının Doğrudan uygulama: İlk bağlama rgiriş sayısı kadar tüm asal için n, daha sonra almak 1herkes için pve qgelen rnerede q<=pve p+q==nbunları topladığınızda.