जुड़वां primes की Nth जोड़ी का पता लगाएं

Question

यदि वे दो से भिन्न होते हैं, तो दो अभाज्य संख्याओं को जुड़वां अपराधों के रूप में परिभाषित किया जाता है। उदाहरण के लिए, 3 और 5 जुड़वां प्राइम हैं जैसा कि 29 और 31 हैं।

एक प्रोग्राम लिखें जो nth जोड़ी को ट्विन प्राइम्स (जहाँ n STDIN से आता है) को ढूँढता है और उन्हें STDOUT पर प्रिंट करता है, एक अल्पविराम और एक स्पेस द्वारा अलग किया जाता है। यह कोड-गोल्फ है, इसलिए सबसे छोटा कोड जीतता है।

नमूना इनपुट:

3

नमूना उत्पादन:

11, 13

Comments

प्रतीक्षा करें ... ताकि उपयोगकर्ता जुड़वाँ primes की nth जोड़ी इनपुट करे, और आप चाहते हैं कि हम इसका उत्पादन करें? तो, उपयोगकर्ता इनपुट क्या है? ;-)

— इस्सी

हम्म ... यह शब्द कुछ अटपटा था! : पी

— जोवेस्टी

Answer 1

हास्केल 118

main=putStrLn.(!!)[show n++", "++show(n+2)|n<-[2..],all((>0).rem n)[2..n-1],all((>0).rem(n+2))[2..n]].(+)(-1)=<<readLn

Brute- फोर्स सभी ट्विन प्राइम और n ^वें पेयर को प्रिंट करता है ।

Comments

अच्छा है! फ़िल्टरिंग फ़ंक्शन को अलग करने और आप के interactबजाय का उपयोग करके और putStrLnभी आगे जा सकते हैं और इसे 105 तक ले जा सकते हैं:a#b=all((>0).rem a)[2..a-b];main=interact$(!!)[show n++", "++show(n+2)|n<-[2..],n#1,(n+2)#2].(+)(-1).read

— फ्लोंक

Answer 2

सीजेएम, 29 26 बाइट्स

Y4]{{:)_{mp}/&!}g}q~*", "*

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

उदाहरण

$ for i in {1..10}; do cjam twin-primes.cjam <<< $i; echo; done
3, 5
5, 7
11, 13
17, 19
29, 31
41, 43
59, 61
71, 73
101, 103
107, 109

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

Y4]        " Push [ 2 4 ].                                                            ";
{          "                                                                          ";
  {        "                                                                          ";
    :)     " Increment each integer in the array.                                     ";
    _      " Duplicate the array.                                                     ";
    {mp}/  " For each integer in the array, push 1 if it's prime and 0 otherwise.     ";
    &!     " Compute the logical NOT of the bitwise AND of the two previous integers. "; 
  }g       " If the result is non-zero, repeat the loop.                              ";
}q~*       " Do the above “N” times, where “N” is the integer read from STDIN.        ";
", "       " Join the array by comma and space.                                       ";

Answer 3

पर्ल, 101 87

87 पात्रों, aschepler की टिप्पणी पर निर्माण

$n=pop;$r='^1$|^(11+?)\1+$';($t=1x$s)=~$r||"11t"=~$r||--$n||die"$s, ",$s+2,$/while++$s

101 वर्ण, पहले का उत्तर

$n=pop;$r=qr/^1$|^(11+?)\1+$/;(1x$s)!~$r&&(1x($s+2))!~$r&&++$i==$n&&say($s,", ",$s+2)&&exit while++$s

उपयोग:

$ perl ./twin_primes.pl 10
107, 109

व्याख्या

$n = pop;                 # Pulls twin prime pair counter from @ARGV
$r = qr/^1$|^(11+?)\1+$/; # The money line - a regex that verifies
                          # if a string of 1's has non-prime length

while ( ++$s ) {          # Loop over integers

                          # '&&' short-circuits
    (1 x  $s    ) !~ $r   # Negated regex match evaluates to true if $s is prime
 && (1 x ($s+2) ) !~ $r   # Same for $s + 2
 &&          ++$i == $n   # Counter to control which pair to print
 && say( $s, ", ", $s+2 ) # Print the line
 && exit                  # Terminate program
}

इस एसओ प्रश्न में गैर-प्रायोगिक रेगेक्स के कामकाज को समझाया गया है ।

Comments

..यह क्या है?

— देखिए

@ TheRare: यह किसी संख्या की प्रधानता की जाँच करने के लिए एक regex का उपयोग करता है।

— जैद

तुमने मेरा दिमाग उड़ा दिया। एक +1 है।

— देखिए

@ TheRare: मैंने एक स्पष्टीकरण जोड़ा कि यह क्यों काम करता है। मुझे यकीन है कि अभी भी सुधार की गुंजाइश है :)

— Zaid

बहुत कुछ जो मैंने किया होगा। कुछ मुंडा चरित्र हैं:$n=pop;$r='^1$|^(11+?)\1+$';($t=1x$s)=~$r||"11$t"=~$r||--$n||exit say("$s, ",$s+2)while++$s

— aschepler

Answer 4

C: 113

n,c,l;main(i){for(scanf("%d",&n),l=2;n;l=c==i?n-=i==l+2,i:l,i+=2)for(c=2;c<i&&i%c++;);printf("%d, %d\n",l-2,l);}

नमूना रन:

$ for i in $(seq 1 10); do echo $i | ./twinprimes; done
3, 5
5, 7
11, 13
17, 19
29, 31
41, 43
59, 61
71, 73
101, 103
107, 109

डेनिस, बेबे और अल्चाइमिस्ट की मदद के लिए धन्यवाद।

Comments

आप scanfकमांड लाइन तर्कों के बजाय का उपयोग करके कुछ बाइट्स बचा सकते हैं । इसके अलावा, o=0अनावश्यक है, क्योंकि oवैश्विक है।

— डेनिस

mainएक डिफ़ॉल्ट इंट वैरिएबल, इन्क्रीमेंटिंग cऔर iअसाइनमेंट और स्टेटमेंट के बीच कोड को छोटा lकर सकता है, लूप के तीसरे ब्लॉक के लिए पहले असाइन किया जा सकता है ताकि आपको ब्रेसेस की जरूरत न पड़े और प्रिंटफ में विभाजक के केवल एक वर्ण का उपयोग कर सके। इसे और अधिक कॉम्पैक्ट बनाएं।

— bebe

धन्यवाद, bebe! मैंने देखा कि मेरे पास भी था c<=i-1, जो कि मूर्खतापूर्ण है।

— मिलिनन

मुझे असाइनमेंट एक्सप्रेशन iमें इंक्रीमेंट करके बाइट शेव करने का कोई रास्ता नहीं दिखता है l, क्योंकि (नया) वैल्यू iको डिक्रीमेंट करने के लिए उपयोग किया जाता है n। कोई सुझाव?

— सहस्राब्दी

अगर मुझे सही ढंग से याद है कि एक जगह है जहाँ आप मुझे बढ़ा सकते हैं, लेकिन मैं इसके संकलक पर निर्भर करता हूँ :(

— bebe

Answer 5

CJam - 26

1e4,{mp},_2f-&qi(=_2+", "\

यह 10000 से छोटे primes के लिए काम करता है; आप 4बड़ी संख्या के लिए एक उच्च प्रतिपादक के साथ बदल सकते हैं (संभावित रूप से 10 ^{20 तक} ), लेकिन कार्यक्रम धीमा हो जाएगा और अधिक मेमोरी का उपयोग करेगा।

इसे http://cjam.aditsu.net/ पर आज़माएं

स्पष्टीकरण:

1e4,सरणी बनाता है [0 1 2 ... 9999]
{mp},केवल प्राइम संख्या का चयन करता
_2f-है सरणी को कॉपी करता है और प्रत्येक आइटम से 2 को घटाता
&है दो सरणियों को प्रतिच्छेद करता है, इस प्रकार प्रत्येक जुड़वां प्राइम जोड़ी से निचले प्राइम को खोजने से
qiइनपुट पढ़ता है और पूर्णांक में कनवर्ट होता
(=है इंडेक्स और संबंधित (कम) जुड़वाँ को प्राइम से
_2+कॉपी करता है और प्राइम को कॉपी करता है और 2 जोड़ता
", "\है कॉमा और स्पेस को दो रिम्स के बीच रखता है

Answer 6

गणितज्ञ - ६३ वर्ण

Print[#-2,", ",#]&@Nest[NestWhile[NextPrime,#,#2-#!=2&,2]&,1,n]

टिप्पणियाँ

यह वास्तव में एक सीधा कार्यान्वयन है। लघुकरण के परिणामस्वरूप लगभग कोई बाधा नहीं थी।

NextPrime एक बिलियन है जो एक नंबर के बाद अगला प्राइम पाता है।

NestWhile[NextPrime,#,#2-#1!=2&,2]& एक अनाम फ़ंक्शन है जो एक नंबर के बाद अगले ट्विन प्राइम जोड़ी के बड़े प्राइम को ढूंढता है।

Nestइस अनाम फ़ंक्शन को लागू करता nहै।

Print[#-2,", ",#]&एक अनाम फ़ंक्शन है जो विशिष्टताओं के अनुसार स्टडआउट करने के लिए प्रिंट करता है। दुःख की बात यह है कि अकेले 63 वर्णों के समाधान के 18 पात्रों को ले लिया गया है।

उदाहरण

In[1]:= Do[                                                                     
         Print[#-2,", ",#]&@Nest[NestWhile[NextPrime,#,#2-#!=2&,2]&,1,n],
         {n, 1, 10}
        ]
3, 5
5, 7
11, 13
17, 19
29, 31
41, 43
59, 61
71, 73
101, 103
107, 109

---

अद्यतन: इस CJam समाधान को फिर से लागू करके दो पात्रों को बचाया जा सकता है । हालाँकि, यह एल्गोरिथम अधिकतम मूल्य को सीमित करता है n। बस Nest...भाग को बदल देंIntersection[#,#-2][[5]]&@Prime@Range[999]

Comments

आपका STDIN कहाँ है? :)

— mfvonh

Answer 7

जावास्क्रिप्ट (E6) 92 96

शॉर्टर और कंप्लेंट - स्टड को पढ़ने / लिखने के लिए और अल्पविराम (स्पेस के साथ) के लिए स्पाइडरमोंकि शेल का उपयोग करें। यह पाता है कि 10000 वीं जोड़ी 1260989, मेरे पीसी पर एक मिनट के भीतर 1260991 के बजाय का
उपयोग करके कम किया जा सकता p[n]=o=nहै p.push(o=n), ताकि पी सरणी विरल हो। लेकिन यह काफी धीमा है, और मैं कोड लंबाई के लिए वैसे भी जीतने वाला नहीं हूं।

m=readline();for(n=3,o=p=[];m;n+=2)p.every(e=>n%e)&&(m-=n-o<3,p.push(o=n));print(o-2+', '+o)

फ़ायरफ़ॉक्स कंसोल में आज़माने के लिए:

m=prompt();for(n=3,o=p=[];m;n+=2)p.every(e=>n%e)&&(m-=n-o<3,p.push(o=n));alert(o-2+', '+o)

Ungolfed

एक ऐसा फंक्शन, जो सभी पहले m जुड़वाँ को मिला (सबसे बड़ा मूल्य लौटाता है):

T=m=>{
  for (o=n=3, p=[2], t=[]; !t[m-1]; n+=2)
    p.every(e => n%e) && (n-o-2 ? 0 : t.push(n), p.push(o=n))
  return t
}

उदाहरण: console.log(T(50))

[5, 7, 13, 19, 31, 43, 61, 73, 103, 109, 139, 151, 181, 193, 199, 229, 241, 271, 283, 313, 349, 421, 433, 463, 523, 571, 601, 619, 643, 661, 811, 823, 829, 859, 883, 1021, 1033, 1051, 1063, 1093, 1153, 1231, 1279, 1291, 1303, 1321, 1429, 1453, 1483, 1489]

बस आखिरी:

L=m=>{
  for (o=n=3,p=[2]; m; n+=2)
    p.every(e => n%e) && (m -= n-o==2, p.push(o=n))
  return o
}

फिर, उस 2 लाइनों को लें और IO जोड़ें

m = prompt()
for (o=n=3, p=[2]; m; n+=2)
  p.every(e => n%e) && (m -= n-o==2, p.push(o=n))
alert('o-2+', '+o)

Answer 8

जे - 49 60 55 51 बाइट्स

मैंने एक सरल दृष्टिकोण के साथ जाने का फैसला किया। फंक्शन tअगले ट्विन प्राइम को इनपुट के रूप में एक प्रमुख संख्या देता है (अब यह fफ़ंक्शन में शामिल है )। फ़ंक्शन fnth ट्विन प्राइम पाता है। यह भी जे में लिखा गया पहला वास्तविक कार्यक्रम है।

f=:[:(":,', ',":@+&2)(4&p:(,{~-=2:)])^:_@>:^:(]`2:)

उदाहरण:

   f 1
3, 5
   f 2
5, 7
   f 3
11, 13
   f 4
17, 19
   f 5
29, 31
   f 100000
18409199, 18409201

बस कुछ भौंहों के लिए, अनगुल्ड संस्करण है।

twin =: (4&p:)(($:@[)`(,)@.(=(]+2:)))]
f    =: ((]-2:),])((0:{twin) ^: (]`(2:)))

स्पष्टीकरण:

f=:[:(":,', ',":@+&2)(4&p:(,{~-=2:)])^:_@>:^:(]`2:)
                     (4&p:(,{~-=2:)])^:_@>:^:(]`2:)
                                        @>:^:(]`2:)  main loop
                                           ^:(]`2:)  Repeat n times, starting with value of 2
                                        @>:          Add one to the current value and apply to the following function.
                     (4&p:(,{~-=2:)])^:_             Get the next twin prime
                                     ^:_             Recurse until there's no change
                          (,{~-=2:)                  If next prime - current value == 2, return current value, otherwise the next prime.
                      4&p:                           Get the next prime
     (":,', ',":@+&2)                                Format the output and add 2 to the second value.
   [:                                                Apply the twin prime to the formatter.

Basically, if n is 4, this creates a recursion tree like this:
 let T be the recursion inside t
 and numbers between rows the return values of according function
   (t * n) 3
-> (t * 4) 3
-> t  t  t  t  3
   17 11 5  3
-> (T  T) (T  T) T  T  3
    17 13  11 7  5  3
-> 17

Comments

विनिर्देशों के अनुरूप इसके लिए थोड़ा और काम करने की आवश्यकता है: "उन्हें STDOUT पर प्रिंट करता है, एक अल्पविराम और एक स्थान द्वारा अलग किया जाता है"। बेशक यह एल्गोरिथ्म के लिए अप्रासंगिक है, लेकिन यह कार्यक्रम की लंबाई बढ़ाता है।

— ज़ाबोलक्स

@Szabolcs बेहतर है?

— देखिए

ज़रूर, +1। J बहुत अच्छा है।

— ज़ाबोलक्स

@Szabolcs यह वास्तव में है। हालाँकि यह मेरे मन को बहुत प्रभावित करता है। हालांकि हर समय आसान हो रहा है (यह मेरे द्वारा लिखा गया पहला कार्यक्रम था)। इसके अलावा, धन्यवाद।

— देखिए

Answer 9

सी #, 265

using System.Linq;class P{static void Main(string[] args){var i=int.Parse(args[0]);int f=0,c=0;for(int j=1;;j+=2){var b=(Enumerable.Range(1,j).Count(x=>j%x==0)==2);if(f==0 && b){f=j;continue;}if(b){c++;if(c==i){System.Console.WriteLine(f+","+j);break;}j-=2;}f=0;}}}

Comments

+1 लेकिन आपको अल्पविरामों को प्रिंट करने के बाद कॉमा के बाद एक स्थान जोड़ने की आवश्यकता है

— क्रिस्टियन

आप दो और चार्ट बचा सकते हैं: .Count(x=>j%x==0)==2)->.Count(x=>j%x<1)<3)

— क्रिस्टियन लुपस्कु

इसके अलावा, आपकी कक्षा को Pइसके बजाय Programऔर पैरामीटर के aबजाय बुलाया जा सकता है args।

— क्रिस्टियन लुपस्कू

के रूप में यह है संकलन नहीं होगा - आप एक अतिरिक्त राशि )के बाद .Count(...)<3। तुम भी बदलकर एक सा बचा सकता है var i=int.Parse(args[0]);int f=0,c=0;के लिए int i=int.Parse(args[0]),f=0,c=0;। आप प्रारंभिक को लूप से निकालकर कुछ बचा सकते हैं, इसलिए c=0;for(int j=1;=> c=0,j=1;for(;।

— बॉब

इसके अलावा, forलूप के शरीर का एक पूर्ण पुनर्लेखन, इसके अलावा एक पूरी तरह से योग्य नाम का उपयोग करके using System: using System.Linq;class P{static void Main(string[]args){int i=int.Parse(args[0]),f=0,c=0,j=1;for(;;j+=2)if(Enumerable.Range(1,j).Count(x=>j%x<1)>2)f=0;else if(f<1)f=j;else{if(++c==i){System.Console.WriteLine(f+", "+j);break;}j-=2;f=0;}}}238 वर्ण।

— बॉब

Answer 10

रूबी 94

require'mathn'
n=gets.to_i
a=1
(a+=2;a.prime?&&(a+2).prime?&&n-=1)while n>0
$><<"#{a}, #{a+2}"

ऑनलाइन टेस्ट: http://ideone.com/B2wxnG

Answer 11

पर्ल, 100 95

$n=<>;$i=3;while($c<$n&&($l=$i++)){$i++until!grep{$i%$_<1}(2..$i-1);$c++if$i-$l<3}print"$l, $i"

Ungolfed:

$n = <>;          # Read from STDIN
$i = 3;           # Tiny hack because I know I don't need the number 2
while ($c<$n && ($l = $i++)) {   # $c counts the pairs, $l is the last prime
  $i++ until ! grep {$i%$_<1} (2..$i-1);   # Increase $i until it's not divisible by anything
  $c++ if $i-$l < 3   # If $i and $l are twin primes, count it
}
print "$l, $i"    # That damned comma added a whole character to my code!

Answer 12

टी-एसक्यूएल (2008+): 344

Brute एक CTE को primes खोजने के लिए मजबूर करता है, n को गिनने के लिए विंडो फंक्शन, उसके बाद जुड़वा को खोजने के लिए जुड़ जाता है। आउटपुट के लिए एक सेकंड में काम करता है <1,000, आउटपुट के लिए एक मिनट के लिए <10,000।

गोल्फ (SQLField यहाँ ):

WITH x(i) AS(SELECT 99 UNION ALL SELECT i-2
FROM x WHERE i>3),z AS(SELECT RANK()OVER(ORDER BY x.i)n,x.i
FROM x x LEFT JOIN x y ON x.i%y.i=0 AND y.i NOT IN(x.i,1)
WHERE y.i IS NULL)SELECT LTRIM(a)+', '+LTRIM(b)FROM(SELECT RANK()
OVER(ORDER BY x.i)n,x.i a,y.i b FROM z x,z y WHERE x.n=y.n-1
AND x.i=y.i-2) o WHERE n=3
OPTION(MAXRECURSION 0)

सुपाठ्य:

WITH x(i) AS (
   SELECT 99
    UNION ALL
   SELECT i-2
   FROM x
   WHERE i > 3
)
,z AS (
SELECT RANK()OVER(ORDER BY x.i)n,x.i
FROM x x
WHERE NOT EXISTS
  (SELECT *
   FROM x y
   WHERE x.i%y.i = 0
    AND y.i NOT IN (x.i,1)
  )
)
SELECT LTRIM(a)+', '+LTRIM(b)
FROM (
    SELECT RANK()OVER(ORDER BY x.i)n,x.i a, y.i b
    FROM z x, z y
    WHERE x.n = y.n+1
    AND x.i = y.i+2
) o
WHERE n = 3
OPTION(MAXRECURSION 0)

Answer 13

गोल्फस्क्रिप्ट 46

~[1 3]\{\{))}%.{:x,{)x\%!},,2=}/*@\-.}do;', '*

ऑनलाइन टेस्ट: लिंक

एनोटेट कोड:

~                       # parse the input as an int
[1 3]                   # add the array [1, 3] on the stack
\                       # invert the items on the stack
{                       # begin loop
  \                     # bring the array to the top of the stack
  {))}%                 # add 2 to each of the numbers in the array
  .{:x,{)x\%!},,2=}/    # check if numbers are prime (leaves a 0 or 1 for both numbers on the stack)
  *                     # multiply the two 0/1 numbers (will only get 1 if both are 1)
  @\-                   # subtract the result from the inital int
  .                     # copy the new int value on the stack to be consumed by the 'do' loop
}do                     # repeat until the initial int was taken down to 0
                        # at this point the array contains the two numbers we're looking for
;                       # get rid of the 0 from the stack
', '*                   # format the output

Answer 14

PHP 5.4, 223

एक छोटा नहीं है, लेकिन एक PHP से कोशिश करते हैं।

$n=$argv[1];function i($k){for($i=2;$i<=(int)($k/2);$i++)if($k%$i==0)return 0;return 1;}function t($t){return (i($t) && i($t+2))?1:0;}$g=1;$d=0;do{if(t($g)==1){if($d<$n){$d++;}else{print_r([$g,$g+2]);break;}}$g++;}while(1);

Answer 15

C 309

अगले प्राइम्स प्राप्त करता रहता है और विषम और फिर भी स्टोर करता है, यदि अंतर दो है तो चेक करता है।

int main()
{
int n;
scanf("%d",&n);
int a=2,b=3,k=2,q;
int odd=1;
int p;
if(n>0)
{
while(n)
{
k++;
p=1;
q=ceil(sqrt(k));
for(int i=2;i<=q;i++)
{
if(k%i==0)
{
p=0;
break;
}
}
if(p)
{
if(odd%2==0)a=k;
else b=k;
if(abs(a-b)==2)n--;
odd++;
}
}
}
printf("%d %d\n",a,b);
return 0;
}

Comments

कृपया वर्गमूल नहीं! for (int i=2;i*i<=k;i++)

— edc65

Answer 16

आर, 91 चार

a=scan();n=1;p=5;while(n!=a){p=p+1;q=p-2;if(sum(!p%%2:p,!q%%2:q)<3)n=n+1};cat(q,p,sep=", ")

कुछ भी नहीं वास्तव में कल्पना:

a=scan()
n=1
p=5
while(n!=a){
    p=p+1
    q=p-2
    if(sum(!p%%2:p,!q%%2:q)<3) # Check that p and q are both primes by checking
       n=n+1                   # the number of zeroes resulting from 
}                              # p modulo each integers 2 to p and same for q
cat(q,p,sep=", ")

उपयोग:

> a=scan();n=1;p=5;while(n!=a){p=p+1;q=p-2;if(sum(!p%%2:p,!q%%2:q)<3)n=n+1};cat(q,p,sep=", ")
1: 10
2: 
Read 1 item
107, 109

Answer 17

जाप, 23 19 बाइट्स

-4 बाइट्स शैगी को धन्यवाद

@µX°j ©°Xj}f
[UU+2]

इसे ऑनलाइन चलाएं

Comments

21 बाइट्स

— झबरा

19

— झबरा

@ सुग्गी नाइस! साभार

— ओलिवर

Answer 18

जावास्क्रिप्ट (Node.js), 162 चार्ट

स्टड से पढ़ता है, आउटपुट के लिए stdout, इनपुट के लिए "जल्दी" बाहर निकलता है <= 0।

t=process.argv[2],c=0,l=1;if(t>0){for(i=0;;i++){p=!Array(i+1).join(1).match(/^1?$|^(11+?)\1+$/);if(p){if(i-2==l){if(c>=t-1){console.log(l+", "+i);break}c++}l=i}}}

उपयोग (ऊपर दी गई लिपि के रूप में ntp.js):

>for /l %x in (0, 1, 10) do node ntp.js %x
>node ntp.js 0
>node ntp.js 1
3, 5
>node ntp.js 2
5, 7
>node ntp.js 3
11, 13
>node ntp.js 4
17, 19
>node ntp.js 5
29, 31
>node ntp.js 6
41, 43
>node ntp.js 7
59, 61
>node ntp.js 8
71, 73
>node ntp.js 9
101, 103
>node ntp.js 10
107, 109

Answer 19

AWK - 129

फ़ाइल fsoe-pairs.awk:

{n=2;N=1
for(;;){if(n in L){p=L[n];del L[n]}else{p=n
if(n-N==2)if(!--$0){print N", "n;exit}N=n}P=p+n++
while(P in L)P+=p;L[P]=p}}

इसे चलाना:

$ awk -f fsoe-pairs.awk
1
3, 5
$ awk -f fsoe-pairs.awk
2
5, 7
$ awk -f fsoe-pairs.awk
10
107, 109

(कमांड के बाद पहली पंक्ति इनपुट है, दूसरा वाला आउटपुट है)

यह खुद के प्राइम जेनरेटर एल्गोरिथ्म पर आधारित है जिसे मैं "एरेस्टॉस्टेनेस की फ्लोटिंग छलनी" कहता हूं (जब तक कि मुझे यह पूरी तरह से वर्णित न हो जाए) जो केवल छलनी के आवश्यक हिस्से और पहले से गणना किए गए अपराधों को संग्रहीत करता है।

Answer 20

पायथन 2 (75)

c=input()
n=3
while c:n+=2;c-=all(n%i&~2for i in range(2,n-2))
print(n-2,n)

तो यहाँ क्या हो रहा है?

सबसे पहले, आइए अभिव्यक्ति को देखें all(n%i&~2for i in range(2,n-2)), जो यह जांचती है कि (n-2,n)क्या जुड़वाँ primes की जोड़ी है।

सरल अभिव्यक्ति all(n%i for i in range(2,n))बस जाँचता है कि nक्या iरेंज में हर विभाजक की कोशिश करके प्रमुख है 2<=i<=n-1, और यह देखते हुए कि सभी अवशेष नॉनज़रो हैं। यह allठीक इसी तरह से जांचता है, क्योंकि पायथन के 0रूप में Falseऔर अन्य सभी संख्याओं के रूप में व्यवहार करता है True।

अब, (n-2)%i==0ठीक वैसा ही देखते हैं जब n%i==2विभाजक होते हैं i>2। तो, हम पर primality जांच प्रदर्शन कर सकते हैं nऔर n-2दोनों के लिए शेष की जाँच करके एक ही समय में 0और 2। इस रूप में किया जा सकता है all(n%i not in [0,2] for i in range(2,n-2))। हम केवल के लिए सीमा में विभाजक का प्रयास करते 2<=i<=n-3हैं n-2, लेकिन यह nतब से ही के लिए पर्याप्त है n-1और n-2जब तक विभाजक नहीं हो सकते n<=4। हम केवल इस जटिलता से बचने के लिए और विभाजक की nशुरुआत से अजीब कोशिश करेंगे ।5i=2

हम अभिव्यक्ति n%i not in [0,2]में गोल्फ n%i&~2, यह याद रखना कि 0गलत और अन्य संख्याएँ हैं True। ऑपरेटर पूर्वता (n%i)&(~2)की वास्तव में आवश्यकता है। बिट-सप्लीमेंट ~2है ...11111101, इसलिए andएक नंबर के 2बाइनरी प्लेस वैल्यू के साथ एक बिट के साथ इसका बिटवाइज़ है । यह 0(यानी, False) केवल 0और केवल 2वही देता है, जो हम चाहते हैं।

ओह! अब हमारे पास यह है कि अभिव्यक्ति all(n%i&~2for i in range(2,n-2))जाँचती है कि nजुड़वा प्राइम जोड़ी की ऊपरी संख्या है या नहीं। जब तक हम उनके बारे में नहीं देखते cहैं, तब तक उन पर क्या करना cहै, इनपुट नंबर कहां है। हम भाजक मुद्दों से बचने के लिए शुरुआत करते हैं 5और गिनती करते 2हैं। हम cहर बार जब हम एक nकाम करते हैं, तब रोकते हैं जब हम मुठभेड़ करते हैं c=0। अंत में, हम उस ट्विन प्राइम जोड़ी को प्रिंट करते हैं जिसे हम समाप्त करते हैं।

Answer 21

टी-एसक्यूएल (2012 +), 255 वर्ण

एक अधिक कॉम्पैक्ट टी-एसक्यूएल ट्विन प्राइम फाइंडर जो थोड़ी गति भी बढ़ाता है।

with t(n)as(select 2+number from spt_values where type='p')select*from(select concat(b,', ',a),rank()over(order by a)from(select n,lag(n)over(order by n)from t where not exists(select*from t f where f.n<t.n and t.n%f.n=0))z(a,b)where a=b+2)r(s,k)where k=2

मानव पठनीय प्रारूप ::

    with t(n)as(
        select 2+number 
        from spt_values 
        where type='p'
    )
    select *
    from(
        select concat(b,', ',a),rank() over (order by a)
        from(
            select n, lag(n) over(order by n)


    from t 
        where not exists(
            select 1 from t f 
            where f.n<t.n and t.n%f.n=0)
    ) z(a,b)
    where a=b+2
) r(s,k)
where k=2

बुनियादी बात यह है कि हम संख्याओं की तालिका (मास्टर..spt_values ​​प्रकार = 'पी') और उपनाम का उपयोग करते हैं जो कि CTE के साथ कुछ छोटा है। हम अपने सेट के लिए 0 या 1 तुच्छ त्रुटियों को खींचने की चिंता को दूर करने के लिए 2 जोड़ते हैं, इसलिए अब हमारे पास 2,2050 के उम्मीदवार हैं।

Z सबसे आंतरिक क्वेरी 2 से 2050 तक सभी प्रकार की हो जाती है, किसी भी संख्या n को फ़िल्टर करने से जो कि n से कम संख्या से विभाज्य है। हम तो एक गंधा टी SQL 2012 विंडोइंग फ़ंक्शन का उपयोग lagहमें पिछले परिणाम खींच देता है कि जेड के परिणाम है, इसलिए अब ए और बी का अभाज्य हैं P[n]और P[n-1]क्रमशः। R क्वेरी आउटपुट स्ट्रिंग बनाता है, और नॉन-ट्विन प्राइम्स को फ़िल्टर करता है और आउटपुट के लिए एक क्रम संख्या भी बनाता है जिसे हम K कहते हैं। अंत में अंतिम क्वेरी R हमें वेरिएबल को बदलकर फ़िल्टर करने और Kth ट्विन प्राइम प्राप्त करने की अनुमति देता है।

Answer 22

गणितज्ञ - 71 बाइट्स

n=Input[];
i=j=0;
While[j<n,i++;If[And@@PrimeQ[x={i,i+2}],j++]];Print@x