गोल्डबैक विभाजन

18

गोल्डबैक अनुमान में कहा गया है कि हर दो से अधिक संख्या को दो अपराधों के योग के रूप में व्यक्त किया जा सकता है। उदाहरण के लिए,

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

हालांकि, एक बार जब हम 10 के लिए कुछ दिलचस्प होता है। इतना ही नहीं 10 भी लिखा जा सकता है

5 + 5

लेकिन यह भी लिखा जा सकता है

7 + 3

चूंकि 10 को दो primes के दो तरीकों के योग के रूप में व्यक्त किया जा सकता है , हम कहते हैं कि 10 का "गोल्डबैक विभाजन" है 2। या अधिक आम तौर पर,

एक नंबर के Goldbach विभाजन लेखन के अलग तरीके की कुल संख्या है n = p + qजहां pऔर qअभाज्य संख्या रहे हैं औरp >= q

आपकी चुनौती एक प्रोग्राम या फ़ंक्शन लिखना है जो एक नंबर का गोल्डबैक विभाजन पाता है। अब, तकनीकी रूप से "गोल्डबैक विभाजन" शब्द का उपयोग केवल सम संख्याओं को संदर्भित करने के लिए किया जाता है। हालांकि, विषम पूर्णांक के बाद से पी + 2 कर सकते हैं भी दो अभाज्य संख्या की राशि के रूप में व्यक्त किया जा अगर p> 2 प्रधानमंत्री है, हम यह सब धनात्मक पूर्णांक के लिए विस्तार होगा ( A061358 )।

आप सुरक्षित रूप से मान सकते हैं कि आपका इनपुट हमेशा एक सकारात्मक पूर्णांक होगा, और आप हमारे किसी भी इनपुट और आउटपुट को ले सकते हैं डिफ़ॉल्ट अनुमत तरीकों , उदाहरण के लिए फ़ंक्शन तर्क और रिटर्न वैल्यू, एसटीडीआईएन और एसटीडीयूएस, एक फ़ाइल को पढ़ना और लिखना, आदि।

सकारात्मक पूर्णांक के गोल्डबैक विभाजन 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

हमेशा की तरह, मानक खामियां लागू होती हैं, और बाइट्स में सबसे कम जवाब जीतता है!

code-golf  math  sequence  number-theory  primes 
— DJMcMayhem
स्रोत
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).
— डेनिस
स्रोत
ओह बेहतर: डी
— जोनाथन एलन
5

पायथन 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])

इस के लिए विचार यह है कि नीचे के आधे हिस्से तक पहुंचने के लिए जाँच करने के लिए नीचे आधे हिस्से में सभी primes की एक सूची रखें, लेकिन मिडपॉइंट के लिए 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
— XNOR
स्रोत
5

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 ऑनलाइन पर आज़मा सकते हैं (पेज को रिफ्रेश कर सकते हैं यदि "रन" बटन दबाए जाने पर "किल" में न बदले)। इनपुट के लिए ग्राफ का निर्माण करने में लगभग 25 सेकंड लगते हैं 3000; कुछ हज़ार से ऊपर के इनपुट समय निकाल लेंगे।

— लुइस मेंडो
स्रोत
1
वह Upper triangular partचाल वाकई मस्त है!
— DJMcMayhem
3

जावास्क्रिप्ट (ईएस 6), 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।

fn-1 से पुनरावर्ती गिनती करके कार्य करता है ; प्रत्येक चरण पर नियंत्रण प्रवाह इस तरह से होता है:

  • x<2||यदि x <2 , संख्या अभाज्य है; वापसी 1 ।
  • n%x&&अन्यथा यदि n x x = 0 , संख्या अभाज्य नहीं है; वापसी n%x।
  • f(n,x-1)अन्यथा, संख्या अभाज्य हो सकती है या नहीं; क्षरण x और पुन: प्रयास करें।

gएक समान फैशन में काम करता है, हालांकि इतना नियंत्रण प्रवाह नहीं है। यह गुणा करके काम करता है च (ख) द्वारा च (ab) प्रत्येक पूर्णांक के लिए ख रेंज में [2, मंजिल (एक / 2)] , तो परिणाम संक्षेप। यह हमें जोड़े की संख्या देता है कि करने के लिए योग एक जहां जोड़ी में दोनों संख्या प्रधानमंत्री हैं, जो कि हम क्या चाहते हैं।

— ETHproductions
स्रोत
चूंकि aसकारात्मक है, b=a>>1आपको एक बाइट को बचाना चाहिए।
— अरनुलद
@ अरनल्ड धन्यवाद! मुझे >>ऑपरेटर को याद रखना चाहिए था ...
— ETHproductions
आप परीक्षण कर सकते हैं f=(n,x=n)=>--x<2||n%x&&f(n,x)?
— अरनुलद
@ अर्नुलद यह जीनियस है, धन्यवाद :)
— ETHproductions
2

05AB1E , 10 8 बाइट्स

अत्यंत अकुशल।

D!f-pO;î

इसे ऑनलाइन आज़माएं! या primes उत्पन्न करने का एक कम कुशल तरीका आज़माएं

व्याख्या

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
— Emigna
स्रोत
क्या आप üइसके बजाय उपयोग नहीं कर सकते ? पसंद है D!fü+r¢?
— मैजिक ऑक्टोपस यूरिन
1
@carusocomputing: मैं नहीं देखता कि यह कैसे काम करेगा। उदाहरण के लिए n=10जो गिनती होगी (10, [5,8,12]) जो कि 2 के बजाय 0 üहै। केवल प्रत्येक जोड़ी के बीच लागू किया जाता है। इसने मुझे प्रयास करने का विचार दिया ã, लेकिन यह दुर्भाग्य से 1 बाइट निकला।
— एमिग्ना
2

जीएपी , 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 ]
— क्रिश्चियन सिवर्स
स्रोत
2

ब्रेकीलॉग , 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
— Fatalize
स्रोत
2

गणितज्ञ, 52 बाइट्स

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

परिणाम एक अनाम फ़ंक्शन के रूप में प्रदान किया जाता है। इस पर एक ग्राफ बनाने की कोशिश करें:

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

अनुक्रम की साजिश

वैसे, कोड OEIS पर डेमो कोड के फ़ंक्शन संस्करण के साथ समान लंबाई है।

— कीउ गण
स्रोत
2
४ ९ बाइट्स:PrimeQ[#~IntegerPartitions~{2}]~Count~{a=True,a}&
— लीजनमैमल
1

जेली , 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
— जोनाथन एलन
स्रोत
1

रैकेट 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
— rnso
स्रोत
0

हास्केल, 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और उन्हें योग।

— nimi
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.