गोल्डबैक का अनुमान

Question

एक प्रोग्राम लिखें जो उपयोगकर्ता को 2 से अधिक पूर्णांक के लिए संकेत देता है।

गोल्डबैच के अनुमान को देखते हुए कि 2 से अधिक पूर्णांक को दो अपराधों के योग के रूप में व्यक्त किया जा सकता है, दो अभाज्य संख्याएँ प्रिंट करें, जो एक साथ जोड़े जाने पर, अनुरोधित संख्या भी प्रदान करें। संपादित करें: प्रोग्राम को केवल अपराधों का एक पृष्ठ प्रिंट करना है, सभी नहीं। उदाहरण के लिए:

4: 2 + 2

6: 3 + 3

8: 3 + 5

10: 5 + 5 या 3 + 7

Comments

"केवल एक जोड़ी को प्रिंट करना है" क्या इसका मतलब है कि हमें अधिक जोड़े छापने की अनुमति है?

— 17 फरवरी को अयिको

मुझे लगता है कि अगर यह आपके कोड की लंबाई को छोटा करता है, लेकिन इसका आयोजन किया जाना चाहिए

— तर्कसंगतता

Answer 1

एपीएल, 34 या 44 बाइट्स

पहला संस्करण 34 प्रतीक लंबा है और मूल एकल-बाइट APL वर्ण से वर्णों तक सीमित है, जैसे कि अभी भी Dyalog APL में समर्थित है:

↑c/⍨n=+/¨c←,∘.,⍨v/⍨~v∊v∘.×v←1↓⍳n←⎕

स्पष्टीकरण:

                               n←⎕   ⍝ ask for a number, store as n
                          v←1↓⍳n     ⍝ generate all integers from 2 to n
                      v∘.×v          ⍝ compute the product table of any two such integers
                v/⍨~v∊               ⍝ select those that don't appear in the product table 
         c←,∘.,⍨                     ⍝ generate all possible pairs of these primes
    n=+/¨c                           ⍝ check which pairs have a sum equal to n
↑c/⍨                                 ⍝ take the first that does

---

दूसरा संस्करण केवल 22 प्रतीक लंबा है, क्योंकि यह πप्राइम नंबर की जांच करने के लिए फ़ंक्शन का शोषण करता है, लेकिन यह केवल NARC2000 में उपलब्ध है उपयोग करता है जो यूनिकोड का उपयोग करता है, इसलिए यूसीएस -2 में बाइट की संख्या 44 है:

2⍴(⌿⍨{∧/0π⍵})(⍪,⌽)⍳⎕-1

स्पष्टीकरण:

                   ⎕    ⍝ ask for a number N
                  ⍳ -1  ⍝ generate all naturals from 1 to N-1
             (⍪,⌽)      ⍝ arrange it into a table of all pairs of naturals with sum N
     {∧/0π⍵}            ⍝ check which pairs are made of all primes
2⍴(⌿⍨       )           ⍝ return the first pair that does

उदाहरण

(The: शीघ्र संख्या के लिए पूछ रहा है)

      2⍴(⌿⍨{∧/0π⍵})(⍪,⌽)⍳⎕-1
⎕:
      4
2 2
      2⍴(⌿⍨{∧/0π⍵})(⍪,⌽)⍳⎕-1
⎕:
      6
3 3
      2⍴(⌿⍨{∧/0π⍵})(⍪,⌽)⍳⎕-1
⎕:
      8
3 5
      2⍴(⌿⍨{∧/0π⍵})(⍪,⌽)⍳⎕-1
⎕:
      124
11 113

Comments

¯2π⍳2πnएक प्रमुख जनरेटर के रूप में काम करेगा ?

— ओबेरॉन

@ ऑबरन πऑपरेटर वास्तव में क्या करता है?

— प्राइमो

डायएडिक πस्विच विथ ⍺: ¯2πxएक्स प्राइम की गणना करता ¯1πxहै, पहला प्राइम है जो एक्स से कम है, 0πxएक्स के लिए टेस्ट प्राइमलिटी है, पहला प्राइम 1πxहै जो एक्स से अधिक है, एक्स 2πxसे कम प्राइम 10πxकी संख्या है, एक्स के डिवोर्स की संख्या 11πxहै, योग है x के सभी भाजक, 12πxऔर 13πxक्रमशः मोबीउस और टोटिएंट फ़ंक्शन हैं। अंतिम लेकिन कम से कम नहीं, मोनैडिक πxx का प्रधान गुणनफल लौटाता है।

— ओबेरॉन

@Oberon जो NARS2000 के लिए विशिष्ट है, है ना? एक दिलचस्प व्याख्याकार लगता है। मैं इसे आज़माऊँगा और अपने उत्तर को संशोधित करूँगा।

— टोबिया २

@ टोबिया यह है? माफ करो फिर। मैंने देखा कि यह कहीं संदर्भित है, लेकिन उन्होंने कभी NARS2000 का उल्लेख नहीं किया। जानकार अच्छा लगा।

— ओबेरॉन

Answer 2

पायथन 2, 75 71 बाइट्स

n=input();k=m=1;p={0}
while{n-k,k}-p:m*=k*k;k+=1;p|={m%k*k}
print n-k,k

Ideone पर इसका परीक्षण करें ।

यह काम किस प्रकार करता है

हम विल्सन की प्रमेय की एक कोरोलरी का उपयोग करते हैं :

हर समय, चर m , k - 1 के भाज्य के वर्ग के बराबर होता है ; k मूल्य 1 पर शुरू होता है और 0 मूल्य पर m ! 1 = 1 । सेट पी 0 से मिलकर बनेगा और वर्तमान मूल्य तक सभी अभाज्य संख्याएँ होंगी k ।

प्रत्येक पुनरावृत्ति में, हम पहले जांचते हैं कि n - k और k दोनों p से संबंधित हैं , जो कि सत्य है यदि और केवल अगर {nk, k} और p का अंतर निर्धारित है तो रिक्त है। यदि यह है, तो स्थिति झूठी है और लूप जारी है।

ध्यान दें कि कश्मीर> 0 , और {n - कश्मीर, कश्मीर} हालत के कुछ सकारात्मक मूल्य के लिए पूरा करेगा n - कश्मीर (यह मानते हुए कि Goldbach का अनुमान सच है), इसलिए 0 में पी झूठे सकारात्मक लिए नेतृत्व नहीं करेंगे।

लूप में, हम k और m को अपडेट करते हैं । M का नया मान m × k² = (k - 1) है! ² × k k = k! ² , और k का नया मान k + 1 है , इसलिए m = (k - 1)! Is अभी भी पहले और बाद में है। नया।

उसके बाद, हम p से m% k × k का मान जोड़ने के लिए सेट यूनियन का प्रदर्शन करते हैं । विल्सन के प्रमेय के आधार पर, यह 1 × k = k होगा यदि k अभाज्य है और 0 × k = 0 है यदि नहीं है।

जब लूप समाप्त होता है, तो हम n - k और k के अंतिम मानों को प्रिंट करते हैं , जो राशि n के साथ primes होंगे ।

Comments

कैसे पृथ्वी पर कि प्रधानमंत्री उत्पन्न एल्गोरिथ्म काम करता है?

— लीक नन

@LeakyNun मैंने एक स्पष्टीकरण जोड़ा है।

— डेनिस

ओह ... यह प्रतिभा है।

— लीक नन

Answer 3

रूबी 2.0 (65)

require'prime'
n=gets.to_i
Prime.find{|i|p [i,n-i]if(n-i).prime?}

Answer 4

PHP - 73 बाइट्स

<?for(;@($n%--$$n?:$o=&$argv[1]>$$n=++$n)||${++$b}^${--$o};);echo"$b+$o";

इनपुट को कमांड लाइन तर्क के रूप में लिया जाता है।

नमूना उपयोग:

$ php goldbach.php 7098
19+7079

Answer 5

GolfScript 41 33 32

~(,2>.-1%]zip{{.,2>\{\%!}+,},!}?

कमांड लाइन तर्क को स्वीकार करता है

echo "14" | ruby golfscript.rb goldbach.gs
-> [2 12]

के साथ इनपुट नंबर के सभी प्रासंगिक विभाजन ढूँढता है:

(,2>.-1%]zip  #If only zip were a one-character command!  It is so often useful.

और फिर पहला विभाजन पाता है जहाँ कोई संख्या प्रमुख नहीं है:

{np,!}? #For each partition, filter down to elements that are not prime, and only accept if there are no such results (since [] is falsey).

कम्पोजिट-चेकिंग ब्लॉक कहां npहै:

{.,2>\{\%!}+,}

यह ब्लॉक उन सभी नंबरों को फ़िल्टर करता है जो किसी दिए गए नंबर को समान रूप से विभाजित करते हैं। यदि ऐसी कोई संख्या नहीं है (इसलिए संख्या प्रधान है), तो इसका परिणाम है [], जो कि गोल्फस्क्रिप्ट में गलत है।

Answer 6

पर्ल 6: 69

$/=get;for grep &is-prime,^$/ {exit say $_,$_-$/ if ($/-$_).is-prime}

Answer 7

आर, 170 112 83 वर्ण

a=scan();b=2:a;p=b[rowSums(!outer(b,b,`%%`))<2];q=p[(a-p)%in%p][1];cat(a,":",q,a-q)

इंडेंट:

a=scan() #Take user input as a numeric
b=2:a
p=b[rowSums(!outer(b,b,`%%`))<2] #Find all primes from 2 to user input
q=p[(a-p)%in%p][1] #Check which a-p also belong to p and takes the first one
cat(a,":",q,a-q)

उपयोग:

> a=scan();b=2:a;p=b[rowSums(!outer(b,b,`%%`))<2];q=p[(a-p)%in%p][1];cat(a,":",q,a-q)
1: 72
2: 
Read 1 item
72 : 5 67 

112 चरित्रों पर पुराना समाधान, उत्तरजीविता के लिए

a=scan();b=2:a;p=b[rowSums(!outer(b,b,`%%`))<2];w=which(outer(p,p,`+`)==a,T);cat(a,":",p[w[1,1]],p[w[1,2]])

इंडेंट:

a=scan()
b=2:a
p=b[rowSums(!outer(b,b,`%%`))<2]
w=which(outer(p,p,`+`)==a,T) #Find the index of valid combinations
cat(a,":",p[w[1,1]],p[w[1,2]]) #Prints the first valid combination

Comments

यह पागल और जिन्न दोनों है !!

— टॉमस

Answer 8

अजगर - १०th

मूल रूप से नट्रिया के उत्तर के दूसरे भाग पर एक सुधार (मैंने इसे 2.7 पर चलाया लेकिन मुझे लगता है कि इसे 3.x के लिए भी काम करना चाहिए)

p=lambda x:all(x%i!=0 for i in range(2,x))
n=input()
for i in range(2,n-1):
    if p(i)&p(n-i): print i,n-i

Comments

क्या :अनिवार्य होने के बाद नई लाइनें और स्थान हैं ?

— मैनीप

टैब को एक स्थान पर कम किया जा सकता है, और प्रिंट से पहले का स्थान हटाया जा सकता है (4 बाइट्स को बंद कर देता है)।

— प्रातः

Answer 9

जावास्क्रिप्ट (ईएस 6) (रेगेक्स), 105

a=/^(xx+?)(?!(xx+)\2+$)x*(?=\1$)(?!(xx+)\3+$)/.exec("x".repeat(prompt()));alert(a[1].length+"+"+a[0].length)

अब आपके पास एक रीजेक्स है जो गोल्डबैक अनुमान का परीक्षण करता है, जिसकी विशेष विशेषताओं (मूल बैक-रेफरेंस सपोर्ट, पॉजिटिव और निगेटिव लुक-फॉरवर्ड) पर कम आवश्यकता होती है।

यह उपयोग करता है String.prototype.repeat() , जो एक्मास्क्रिप्ट 6 वें संस्करण के प्रस्ताव का हिस्सा है। वर्तमान में, यह कोड केवल फ़ायरफ़ॉक्स पर काम करता है।

मुझे वास्तव में एक बेहतर भाषा की आवश्यकता है जो रीगेक्स के साथ काम करते समय कमांड को सुव्यवस्थित करे ...

Answer 10

स्काला, 286 192 172 148 वर्ण

सबसे तेज़ नहीं है लेकिन यह काम करता है। 10 के लिए गोल्डबैक जोड़े की सूची प्राप्त करने के लिए जी (10) पर कॉल करें।

def g(n:Int)={def p(n:Int,f:Int=2):Boolean=f>n/2||n%f!=0&&p(n,f+1)
s"$n : "+(for(i<-2 to n/2;j=n-i if p(i)&&p(j))yield s"$i + $j").mkString(" or ")}

C ++ में रूपांतरण सीधा है।

Answer 11

C - 139 129 अक्षर

a,b;i(x,y){return x>y?x%y?i(x,y+1):0:x>1;}main(){scanf("%i",&a);for(b=a/2;b-->1;)i(b,2)&&i(a-
b,2)&&printf("%i:%i+%i\n",a,b,a-b);}

Comments

आप intअपने फ़ंक्शन में घोषणाओं को हटाकर 8 वर्णों को शेव कर सकते हैं i। आप एक और 2 अक्षर बचा सकते हैं ifऔर दूसरे डबल एम्परसेंड में जोड़कर बचा सकते हैं :i(b,2)&&i(a-b,2)&&printf(...)

— जोश

धन्यवाद! ऐसा नहीं सोचा था &&। (मुझे टाइप साइलेंसिंग करने की आदत नहीं होगी ...)

— ओबेरॉन

मुझे नेस्टेड टर्नरी के आपके उपयोग से प्यार है।

— जोश २

Answer 12

newLISP - 169 148 चार्ट

(define(p n)(=(length(factor n))1))
(define(g n)(when(even? n)(for(i 3 n 2)
(and(p i)(p(- n i))(println n {: } i { }(- n i))))))
(g(int(read-line)))

इसे चलाने के लिए कोड शामिल है। परिणाम बहुत उदार हैं ...

72: 5 67
72: 11 61
72: 13 59
72: 19 53
72: 29 43
72: 31 41
72: 41 31
72: 43 29
72: 53 19
72: 59 13
72: 61 11
72: 67 5

Answer 13

ऋषि, ६०

स्कोर में समान है और रिज़ॉल्यूशन को महसूस करता है , लेकिन मुझे लगता है कि यह पोस्ट करने के लिए पर्याप्त है।

i=n=input()
while not{i,n-i}<set(primes(n)):i-=1
print i,n-i

Answer 14

ऋषि , ६५ ६२

n=input()
i=0
p=is_prime
while p(i)*p(n-i)==0:i+=1
print i,n-i

फ़ाइल में उपरोक्त के साथ goldbach.sage, इसे एक टर्मिनल में चलने वाले ऋषि के साथ निष्पादित करें:

sage: %runfile goldbach.sage 

इस p=is_primeविचार के लिए @boothby को धन्यवाद ।

Comments

आप सेटिंग करके इसे 62 तक नीचे ला सकते हैं p=is_prime।

— बूथ 13

Answer 15

हास्केल, 97 सी

g n=head[(a,b)|let q=p n,a<-q,b<-q,a+b==n]
p n=filter c[2..n]
c p=null[x|x<-[2..p-1],p`mod`x==0]

स्पष्टीकरण:

• g"गोल्डबैक" फ़ंक्शन है। कॉलिंग g nआपको जोड़े जाने वाले primes की जोड़ी देती है n।
• pएक ऐसा फंक्शन है जो कम से कम प्राइम की सूची तैयार करता है n।
• cप्रधानमंत्री चेकर फ़ंक्शन को परिभाषित करने के लिए उपयोग किया जाता है p।

उदाहरण चलता है:

*Main> g 4
(2,2)
*Main> g 6
(3,3)
*Main> g 8
(3,5)
*Main> g 10
(3,7)
*Main> g 12
(5,7)
*Main> map g [4,6..100]
[(2,2),(3,3),(3,5),(3,7),(5,7),(3,11),(3,13),(5,13),(3,17),(3,19),(5,19),(3,23),(5,23),(7,23),(3,29),(3,31),(5,31),(7,31),(3,37),(5,37),(3,41),(3,43),(5,43),(3,47),(5,47),(7,47),(3,53),(5,53),(7,53),(3,59),(3,61),(5,61),(7,61),(3,67),(5,67),(3,71),(3,73),(5,73),(7,73),(3,79),(5,79),(3,83),(5,83),(7,83),(3,89),(5,89),(7,89),(19,79),(3,97)]

Answer 16

गणितज्ञ ५६

यह इनपुट पूर्णांक के लिए सभी समाधान देता है।

Select[Tuples[Prime@Range@PrimePi[n = Input[]], 2], Tr@# == n &]

उदाहरण के लिए, जब 1298 इनपुट है ...

{{7, 1291}, {19, 1279}, {61, 1237}, {67, 1231}, {97, 1201}, {127, 1171}, {181, 1117}, {211, 1087, { 229, 1069}, {277, 1021}, {307, 991}, {331, 967}, {379, 919}, {421, 877}, {439, 859}, {487, 811}, {541, 757}, {547, 751}, {571, 727}, {607, 691}, {691, 607}, {727, 571}, {751, 547}, {757, 541}, {811, 487} , {859, 439}, {877, 421}, {919, 379}, {967, 331}, {991, 307}, {1021, 277}, {1069, 229}, {1087, 211}, { 1117, 181}, {1171, 127}, {1201, 97}, {1231, 67}, {1237, 61}, {1279, 19}, {1291, 7}

जैसा कि लिखा गया है, यह प्रत्येक समाधान को दो बार लौटाता है।

Union[Sort/@ %]

{{7, 1291}, {19, 1279}, {61, 1237}, {67, 1231}, {97, 1201}, {127, 1171}, {181, 1117}, {211, 1087, { 229, 1069}, {277, 1021}, {307, 991}, {331, 967}, {379, 919}, {421, 877}, {439, 859}, {487, 811}, {541, 757}, {547, 751}, {571, 727}, {607, 691}}

Comments

इनपुट 2, एक ओरेकल से पूछें कि क्या यह

— रुकता है

Answer 17

जूलिया, 62 शुल्क (85 शीघ्र)

julia> g(n)=collect(filter((x)->sum(x)==n,combinations(primes(n),2)))
g (generic function with 1 method)

julia> g(88)
4-element Array{Array{Int64,1},1}:
 [5,83] 
 [17,71]
 [29,59]
 [41,47]

Comments

यह उपयोगकर्ता को संकेत नहीं देता (आवश्यकतानुसार), क्या यह?

— रेस

नहीं, यह ध्यान नहीं दिया। यह अभी कई पात्रों को जोड़ देगा। g(int(readline(STDIN)))

— ggg

Answer 18

जीटीबी , 31

अपने TI-84 कैलकुलेटर के लिए

`A:.5A→B@%;A,4)4$~B+1,B-1#~B,B&

कोई प्राइम बिल्ट-इन नहीं।

उदाहरण चलता है

?4
               2
               2
?6
               3
               3
?8
               3
               5
?10
               5
               5

Answer 19

जावास्क्रिप्ट, 139 137 136

a=prompt();function b(n){for(i=2;i<n;i++)if(n%i<1)return;return 1}for(c=2,r=1;c<a&&r;c++)if(b(c)&&b(a-c))alert(a+": "+c+" + "+(a-c)),r=0

Comments

मुझे लगता है कि आप के return;बजाय 2 से अधिक चार दाढ़ी कर सकते हैंreturn 0;

— ñ̷͉h̷̭̿a̸̡̅ẗ̵̨́h cand̷̰̀ĥ̷̳

Answer 20

अजगर 3 - 150 143 अक्षर

पुराना संस्करण (150 वर्ण):

p=lambda n:0 in[n % i for i in range(2,n)]
n=int(input())
[print('%d+%d'%(a, b))for b in range(2,n)for a in range(2,n)if not(a+b!=n or p(a) or p(b))]

नया संस्करण (ProgramFOX का धन्यवाद):

p=lambda n:0 in[n%i for i in range(2,n)]
n=int(input())
[print('%d+%d'%(a,b))for b in range(2,n)for a in range(2,n)if not((a+b!=n)|p(a)|p(b))]

यह प्रत्येक संयोजन को प्रिंट करता है, उदाहरण के लिए:
4 2 + 2
10 7 + 3 5 + 5 3 + 7

Comments

|सुरक्षित रूप से बूलियन प्रकार के साथ उपयोग किया जा सकता है, इसलिए(a+b!=n)|p(a)|p(b)

— n .h̷̭̿a̸̡̅ẗ̵̨́h̷̰̀ĥ̷̳d

उपयोग करने से भी छोटा: print([(a,b)for b in range(2,n)for a in range(2,n)if not((a+b!=n)|p(a)|p(b))])(टपल्स की एक सूची प्रिंट करता है, जिसका योग n है)। 8 बाइट बचाता है।

— 16:52

इसके अलावा उपयोग r=range(2,n)और संदर्भित rकुछ और बचाता है।

— agtoever

Answer 21

क्ष [११६ वर्ण]

y where all each{{2=count where 0=(x mod)each til x+1}each x}each y:{a where x=sum each a:a cross a:til x}"I"$read0 0

प्राइम नंबर खोजने के लिए कोई इनबिल्ट फंक्शन नहीं।

इनपुट

72

उत्पादन

5  67
11 61
13 59
19 53
29 43
31 41
41 31
43 29
53 19
59 13
61 11
67 5

Answer 22

अजगर - 206

पार्टी में थोड़ी देर हो गई लेकिन मैं अपने गोल्फ कौशल का अभ्यास कर रहा हूं।

इससे पहले कि मैं यह सवाल पाता मैं वास्तव में इसे कोडित करता! तो मेरा सुंदर लंबोदर शामिल नहीं है कि अन्य पायथन समाधान का उपयोग करें।

import math
def p(n):
    if n%2==0&n>2:return False
    for i in range(3,n):
        if n%i==0:return False
    return True 
X=int(input())
for i in range(2,X):
    if p(i)&p(X-i):print i,X-i;break

Answer 23

जे - 35 32 चार

"प्रॉम्ट यूजर" हर J गोल्फर का बैन है। वहाँ मेरे सभी कड़ी मेहनत के पात्रों जाओ!

p:(n,n)#:i.&n,+/~p:i.n=:".1!:1]1

व्याख्या की:

• ".1!:1]1- 1!:1इनपुट (फाइल हैंडल) से एक स्ट्रिंग ( ) में पढ़ें1 ) और इसे एक नंबर ( ".) में बदलें।
• p:i.n=:- इस नंबर को वेरिएबल पर असाइन करें n, और फिर पहले लेंn प्राइम्स लें।
• +/~- एक अतिरिक्त टेबल बनाएं, nचौड़ी औरn ऊंची।
• i.&n, - तालिका को एकल सूची में बदल दें, और फिर पहली घटना के सूचकांक का पता लगाएं n , जो मौजूद है यदि गोल्डबैक का अनुमान सही है।
• p:(n,n)#: - अनुक्रमणिका से पंक्ति और स्तंभ को पुनः प्राप्त करें, और संबंधित प्राइम्स लें।

उपयोग:

   p:(n,n)#:i.&n,+/~p:i.n=:".1!:1]1
666
5 661
   p:(n,n)#:i.&n,+/~p:i.n=:".1!:1]1
1024
3 1021

प्रॉम्प्ट एक आवश्यकता नहीं थी, यहाँ एक 25 वर्ण क्रिया है:

(,~p:@#:]i.~&,+/~@:p:@i.)

Answer 24

जेली , 8 बाइट्स (गैर-प्रतिस्पर्धात्मक)

_ÆRfÆR.ị

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

_ÆRfÆR.ị  Main link. Argument: n (integer)

 ÆR       Prime range; yield all primes in [1, ..., n].
_         Subtract all primes from n.
   fÆR    Filter; intersect the list of differences with the prime range.
      .ị  At-index 0.5; yield the last and first element.

Answer 25

जूलिया, 50 49 बाइट्स

~=primes;n=ARGS[]|>int
(n-~n)∩~n|>extrema|>show

इसे ऑनलाइन आज़माएं!

यदि कोई फ़ंक्शन स्वीकार्य था, तो कोड को 32 बाइट्स तक छोटा किया जा सकता है :

~=primes
!n=(n-~n)∩~n|>extrema

यह काम किस प्रकार करता है

~=primesबिल्ट-इन प्राइम्स फ़ंक्शन के लिए एक उपनाम बनाता है जो अपने तर्क तक सभी प्रमुख संख्याओं की सूची देता है। n=ARGS[]|>intपहले कमांड-लाइन तर्क को पार्स करता है जैसा कि इसे n में सेव करता है ।

एक उपयुक्त जोड़ी को खोजने के लिए, हम पहले उपरोक्त प्राइम रेंज की गणना करते हैं ~n। फिर, n-~nइन primes और n के सभी मतभेदों को जन्म देता है ।

इंटरसेक्टिंग ( ∩) प्राइम रेंज के साथ परिणाम के द्वारा , हम यह सुनिश्चित करते हैं कि शेष प्राइम्स p ऐसे n - p हैं भी एक प्राइम है।

अंत extremaमें, चौराहे में सबसे कम और उच्चतम प्राइम लेता है, इसलिए उनकी राशि n होनी चाहिए ।

Answer 26

एसक्यूएल, 295 284

Postgresql में:

create function c(c int) returns table (n int, m int) as $$ 
with recursive i(n) as
(select 2 union all select n+1 from i where n<c), 
p as (select * from i a where not exists 
(select * from i b where a.n!=b.n and mod(a.n,b.n)=0))
select * from p a, p b where a.n+b.n=c 
$$ language sql;

यह आधे स्थान में करने में सक्षम होना चाहिए, हालांकि, अगर यह "पुनरावृत्ति में कोई बाहरी जुड़ाव नहीं है", "पुनरावृत्ति में कोई उपश्रेणी" जैसी चीजों के लिए नहीं थे ...

यहाँ उत्पादन है:

postgres=# select c(10);
   c   
-------
 (3,7)
 (5,5)
 (7,3)
(3 rows)

postgres=# select c(88);
   c    
---------
 (5,83)
 (17,71)
 (29,59)
 (41,47)
 (47,41)
 (59,29)
 (71,17)
 (83,5)
(8 rows)

Answer 27

बैच - 266

@echo off&setLocal enableDelayedExpansion&for /L %%a in (2,1,%1)do (set/aa=%%a-1&set c=&for /L %%b in (2,1,!a!)do set/ab=%%a%%%%b&if !b!==0 set c=1
if !c! NEQ 1 set l=!l!%%a,)&for %%c in (!l!)do for %%d in (!l!)do set/ad=%%c+%%d&if !d!==%1 set o=%%c + %%d
echo !o!

बड़े करीने से सेट करें -

@echo off
setLocal enableDelayedExpansion
for /L %%a in (2,1,%1) do (
    set /a a=%%a-1
    set c=
    for /L %%b in (2,1,!a!) do (
        set /a b=%%a%%%%b
        if !b!==0 set c=1
    )
    if !c! NEQ 1 set l=!l!%%a,
)
for %%c in (!l!) do for %%d in (!l!) do (
    set /a d=%%c+%%d
    if !d!==%1 set o=%%c + %%d
)
echo !o!

Answer 28

पर्ल 5, 58 बाइट्स

57, प्लस 1 के लिए -nE

/^(11+?)(?!(11+)\2+$)1*(?=\1$)(?!(11+)\3+$)/;say for$1,$&

इनपुट और आउटपुट एकात्मक हैं। उदाहरण:

$ perl -nE'/^(11+?)(?!(11+)\2+$)1*(?=\1$)(?!(11+)\3+$)/;say for$1,$&'
1111111111
111
1111111

टोपी की नोक।

Answer 29

ओरेकल SQL 11.2, 202 बाइट्स

WITH v(x,y,s)AS(SELECT LEVEL,LEVEL,0 FROM DUAL CONNECT BY LEVEL<=:1 UNION ALL SELECT x,y-1,s+SIGN(MOD(x,y))FROM v WHERE y>1),p AS(SELECT x FROM v WHERE x-s=2)SELECT a.x,b.x FROM p a,p b WHERE:1=a.x+b.x;   

संयुक्त राष्ट्र के golfed

WITH v(x,y,s) AS
(
  SELECT LEVEL,LEVEL,0 FROM DUAL CONNECT BY LEVEL<=:1 
  UNION ALL 
  SELECT x,y-1,s+SIGN(MOD(x,y))FROM v WHERE y>1
)
,p AS (SELECT x FROM v WHERE x-s=2)
SELECT a.x,b.x 
FROM p a,p b 
WHERE :1=a.x+b.x;   

Answer 30

पायथन 3, 107 बाइट्स

b=lambda x:all(x%y for y in range(2,x))
g=lambda x,i=2:((i,x-i)if b(i)&b(x-i)else g(x,i+1))if(i<x)else 0

b (x) x के लिए एक प्रायोगिक परीक्षण है, और g (x) संख्याओं के माध्यम से पुनरावर्तन करता है जो दो अपराधों के लिए उपयुक्त है।