एक प्राइमरी गैप दो लगातार प्राइम के बीच का अंतर है। अधिक विशेष रूप से, अगर पी और क्यू के साथ अभाज्य हैं पी < क्ष और पी +1, पी 2, ..., क्ष -1 नहीं हैं अभाज्य संख्या, अभाज्य p और q के अंतराल को परिभाषित n = क्ष - पी । अंतर को पी द्वारा शुरू किया गया है , और लंबाई एन है ।

यह ज्ञात है कि मनमाने ढंग से बड़े अंतराल मौजूद हैं। यही है, n को देखते हुए लंबाई n या बड़ा का एक मुख्य अंतर मौजूद है । हालांकि, लंबाई n का एक मुख्य अंतर मौजूद नहीं हो सकता है (लेकिन एक बड़ा एक होगा)।

चुनौती

एक सकारात्मक पूर्णांक को देखते हुए n, पहला प्राइम आउटपुट जो लंबाई nया बड़े के अंतराल को शुरू करता है ।

उदाहरण के लिए, इनपुट के 4लिए आउटपुट होना चाहिए 7, क्योंकि 7 और 11 पहले लगातार होने वाले प्राइम हैं जो कम से कम 4 से भिन्न होते हैं (पिछले अंतराल 1 हैं, 2 से 3 तक; 2, 3 से 5 तक; और 2, 5 से; 7)। इनपुट के 3लिए उत्तर भी होना चाहिए 7(लंबाई 3 की कोई कमी नहीं है)।

सशर्त नियम

एल्गोरिथ्म को सैद्धांतिक रूप से उच्च स्तर के लिए काम करना चाहिए n। व्यवहार में, यह स्वीकार्य है यदि कार्यक्रम समय, स्मृति या डेटा-प्रकार के आकार तक सीमित है।
इनपुट और आउटपुट किसी भी उचित माध्यम से लिया जा सकता है ।
प्रोग्राम या फ़ंक्शंस की अनुमति है, किसी भी प्रोग्रामिंग भाषा में । मानक खामियों को मना किया जाता है।
बाइट्स में सबसे छोटा कोड जीतता है।

परीक्षण के मामलों

Input -> Output

1        2
2        3
3        7
4        7
6        23
10       113
16       523
17       523
18       523
30       1327
50       19609
100      370261
200      20831323

— लुइस मेंडो
स्रोत

गैया , 6 बाइट्स

zṅọ⊃∆ṇ

यह बेहद अक्षम है ( 16मेरी मशीन पर गणना करने के लिए परीक्षण के मामले में एक घंटे से अधिक समय लगा।)

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

व्याख्या

अनुक्रम में लगता है कि संपत्ति एक (n) <= 2 ^ n है ।

z       Push 2^input.
 ṅ      Get the first 2^input prime numbers.
  ọ     Get the deltas of the list.
   ⊃∆   Find the index of the first that is greater than or equal to the input.
     ṇ  Push the index-th prime number.

— बिजनेस कैट
स्रोत

9

जेली , 10, 9, 8 10 बाइट्स

Æn_$:ð1#»2

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

@Dennis को धन्यवाद दो बाइट्स बचाए! (और फिर किनारे के मामलों के कारण फिर से जोड़ा गया)

स्पष्टीकरण:

Æn          #   The next prime after 'P'
  _$        #   Minus 'P'
    :       #   Divided by 'N'
            #
            # This will give a falsy value unless the distance to the next prime is >= N
            #
     ð      # Treat all of that as a single dyad (fucntion with two arguments). 
            # We'll call it D(P, N)
            #
      1#    # Find the first 'P' where D(P, input()) is truthy
        »2  # Return the maximum of that result and 2

— DJMcMayhem
स्रोत

क्या हम निश्चित रूप से जानते हैं कि परिणाम हमेशा इनपुट की तुलना में अधिक-या-बराबर-बराबर होगा? ( #यहां इनपुट से गिनेंगे) यह मान लेना उचित लगता है, लेकिन किसी के लिए मेरे पास कोई विचार नहीं है यदि यह एक मान्य धारणा है। संपादित करें: (यदि आवश्यक हो) ठीक करने के लिए FYI करें2ð

— योनातन एलन

5

@JonathanAllan बर्ट्रेंड के पोस्ट का तात्पर्य है कि एक प्रधानमंत्री का अंतर प्रधानमंत्री की तुलना में कड़ाई से कम है।

— डेनिस

@ डेनिस शानदार आपको बहुत बहुत धन्यवाद! TMYK ...

— जोनाथन एलन

4

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

2//.x_ /;NextPrime@x-x<#:>x+1&

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

मैथेमेटिका, 35 बाइट्स

(t=2;While[NextPrime@t-t<#,t++];t)&

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

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

Prime@Min@Position[s=Differences@Prime@Range[(r=#)^3+1],#&@@Select[s,#>=r&]]&

— J42161217
स्रोत

चतुर चालाक ... आपको यह सुनिश्चित करने की भी आवश्यकता नहीं है कि दोनों प्रमुख हैं pऔर q... पहला कोड अमान्य लगता है, हालांकि, क्योंकि यह केवल 65535 तक जाता है जब तक आप स्पष्ट रूप से तर्क नहीं खिलाते हैं MaxIterations।

— जुंगह्वान मिन

इसके अलावा, 35-बाइट संस्करण के लिए -2 बाइट्स:(For[t=2,NextPrime@t-t<#,t++];t)&

— जुंगह्वान मिन

4

हास्केल , 106 102 93 77 73 72 बाइट्स

यह पहले प्राइम की अनंत सूची बनाता है, फिर प्राइम गैप की तलाश करता है। प्रमुख सूची यहां से ली गई थी । यह शायद छोटा किया जा सकता है, लेकिन मुझे अभी तक पता नहीं चला है :)

-4 बाइट्स के लिए @BruceForte और -1 बाइट के लिए @Zrabrab को धन्यवाद!

f n=[x|(y,x)<-zip=<<tail$[n|n<-[2..],all((>0).rem n)[2..n-1]],y-x>=n]!!0

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

— flawr
स्रोत

निश्चित रूप से कुछ

— सनक

zip=<<tail$[...]एक बाइट बचाता है।

— जर्बर्ग

"यह पहले, फिर प्राइम की अनंत सूची बनाता है ...": ठीक है, तो कभी नहीं होना चाहिए? (यानी, यह केवल एक असीम रूप से लंबे समय के बाद होगा, "पहली बार उत्पन्न होने का समय" प्रक्रियात्मक रूप से अपराधों की एक अनंत सूची है)

— ओलिवियर दुलाक

1

हास्केल आलसी मूल्यांकन का उपयोग करता है, इसलिए केवल उस सूची की कई प्रविष्टियां उत्पन्न होती हैं जो वास्तव में उपयोग की जाती हैं। तो उन बिंदुओं को उस बिंदु तक उत्पन्न किया जाता है जहां हम वास्तव में अंक पाते हैं। यदि आप इसे n

— आजमाते हैं

1

वैसे यह एक अनंत सूची है, परिभाषा के अनुसार इसका कोई अंत नहीं है। मैंने जो वर्णन किया है वह सामान्य व्याख्याकारों में हुड के नीचे क्या हो रहा है, लेकिन यह भाषा के हिस्से के रूप में निर्दिष्ट नहीं है, इसलिए आप यह नहीं बता सकते हैं!

— दोष

3

पायथ - 14 बाइट्स

यह [1, inf) से फ़िल्टर होता है, primality ( P_) से फ़िल्टर होता है और यह कि (n, inf) से फ़िल्टर किया गया अगला प्राइम, इनपुट के लिए एक अलग> = है।

f&P_T<tQ-fP_Yh

टेस्ट सूट ।

— Maltysen
स्रोत

3

पॉवरशेल , 97 96 91 बाइट्स

param($n)for($a=$b=2){for(;'1'*++$b-match'^(?!(..+)\1+$)..'){if($b-$a-ge$n){$a;exit}$a=$b}}

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

इनपुट $n, सेट $aऔर के $bबराबर लेता है 2, फिर एक अनंत forलूप में प्रवेश करता है । अंदर, हम अगले प्रधानमंत्री$b तक पहुंचने तक लूप करते हैं । तब हम जांचते हैं $b-$aकि क्या (यानी, गैप) -gरीटरथेनर क्वालिफाइड eहै $n। अगर यह है, हम उत्पादन $aऔर exit। अन्यथा हम सेट $aहोने के लिए $bऔर वेतन वृद्धि $bऔर हमारी अगली खोज शुरू करते हैं।

चेतावनी: यह बड़े इनपुट के लिए धीमा है । वास्तव में, यह 50TIO पर 60 के दशक के भीतर या उच्च परीक्षणों को पूरा नहीं कर सकता है । ओह अच्छा।

— AdmBorkBork
स्रोत

3

भूसी , १३ ११ १० बाइट्स

´ȯ!V≥⁰Ẋ-İp

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

´       İp  -- with the primes
 ȯ!         -- get the value at position
      Ẋ-    -- where the difference of the current and next prime
   V≥⁰      -- is greater or equal than the input N

— ბიმო
स्रोत

3

मैथेमेटिका, 39 बाइट्स

(For[i=2;p=NextPrime,i+#>p@i,i=p@i];i)&
(* or *)
(For[i=1;p=Prime,p@i+++#>p@i,];p[i-1])&

33 बाइट संस्करण (मान्य नहीं है क्योंकि यह केवल 65535 वें प्राइम तक जाता है)

p=NextPrime;2//.i_/;p@i-i<#:>p@i&

— जंगहवान मिन
स्रोत

2

पायथन 2 , 96 88 बाइट्स

- 8 बाइट्स @Maltysen को धन्यवाद

n,p,r=input(),3,[2]
while p-r[-1]<n:r+=[p]*all(p%i for i in range(2,p));p+=1
print r[-1]

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

— officialaimm
स्रोत

1

बाइट्स का एक गुच्छा बचाया: repl.it/JwBe

— माल्टीसेन

2

पर्ल 6 , 63 बाइट्स

->\d{(grep &is-prime,^∞).rotor(2=>-1).first({-d>=[-] $_})[0]}

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

— शॉन
स्रोत

2

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

gNestWhile[p=NextPrime,2,p@#-#<g&]

Functionपहले तर्क के साथ g। के साथ शुरू 2, फ़ंक्शन को p=NextPrimeबार-बार लागू करता है जब तक कि p@#-#<g&देता है True(वर्तमान प्राइम और अगले प्राइम के बीच का अंतर कम है g)।

— ngenisis
स्रोत

2

आर + जीएमपी, 55 बाइट्स

जीएमपी लाइब्रेरी से अगली बार फ़ंक्शन का उपयोग करता है

s=2;n=scan();while((x=gmp::nextprime(s))-s<n)s=x;cat(s)

— MickyT
स्रोत

आपको cat(s)अंत में जोड़ने की आवश्यकता है । पूर्ण मुद्रण पूर्ण कार्यक्रमों में काम नहीं करता है।

— JAD

2

रूबी , 61 बाइट्स

->g{*r,f=2,3;f+=1while r.find{|n|f%n<1}||r<<f&&g>f-z=r[-2];z}

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

— जीबी
स्रोत

2

सी = 141 109 बाइट्स; सी ++, डी = 141 बाइट्स; सी #, जावा = 143 बाइट्स

चेतावनी : कम प्रदर्शन ALGORITHM

यह कोड g(200)10 मिनट के लिए प्राइम गैप की गणना करने में सक्षम नहीं था । इसके लिए g(100), इसे 10 सेकंड (C ++ संस्करण) की आवश्यकता थी

C ++ और D संस्करण:

int p(int d){for(int i=2;i<=d/2;++i){if(!(d%i))return 0;}return 1;}int g(int d){int f=2,n=3;while(n-f<d){f=n;do{++n;}while(!p(n));}return f;}

सी # और जावा संस्करण:

int p(int d){for(int i=2;i<=d/2;++i){if(d%i==0)return 0;}return 1;}int g(int d){int f=2,n=3;while(n-f<d){f=n;do{++n;}while(p(n)==0);}return f;}

सी संस्करण, -32 बाइट्स सीटिंगकैट के लिए धन्यवाद:

i;p(d){for(i=2;d/2/i;)if(!(d%i++))return 0;return 1;}f;n;g(d){for(f=2,n=3;n-f<d;)for(f=n;!p(++n););return f;}

C # / Java और C / C ++ / D संस्करण के बीच अंतर: !p(n)<==>p(n)==0

— HatsuPointerKun
स्रोत

उल्टा कर सकते हैं return 0; return 1और हटाने !से पहलेp(++n)

— ceilingcat

d%i==0और !(d%i)हो सकता है d%i<0। इसके अलावा, डी के टेम्प्लेट सिस्टम का उपयोग करके डी में समाधान हो सकता है

T p(T)(T d){for(T i=2;i<=d/2;++i)if(d%i<1)return 0;return 1;}T g(T)(T d){T f=2,n=3;while(n-f<d){f=n;do++n;while(!p(n));}return f;

:। (के बाद ब्रेसिज़ को हटाने forऔर doसी ++ के लिए भी लागू हो सकता है)

— Zacharý

मैंने अलग डी संस्करण पोस्ट किया है, जो डी विशिष्ट चाल का उपयोग करता है जो सी / सी ++ / सी # / जावा में नहीं मिल सकता है।

— Zacharý

int p(int d){for(int i=2;i<=d/2;++i)if(!(d%i))return 0;return 1;}int g(int d){int f=2,n=3;while(n-f<d){f=n;do++n;while(!p(n));}return f;}

<- कि C ++ संस्करण के लिए काम करना चाहिए

— Zacharý

2

डी, 127 125 122 बाइट्स

चेतावनी: कम प्रदर्शन ALGORITHM !!

T p(T)(T d){T r;for(T i=2;i<=d/2;)r=d%i++<1||r;return r;}T g(T)(T d){T f=2,n=3;while(n-f<d){f=n;while(p(++n)){}}return f;}

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

कैसे?

HatsuPointerKun फिर से, लेकिन मैं डी विशिष्ट टोना करूँगा।

टेम्पलेट सिस्टम प्रकारों का अनुमान लगा सकता है T p(T)(T d), और C ++ से कम है
r=d%i++<1||r, डी विशिष्ट shenanigans, C / C ++ में काम कर सकते हैं, लेकिन मुझे नहीं पता।
p(++n), जैसा कि ऊपर, सुनिश्चित नहीं है कि यह C / C ++ में काम करता है
while(p(++n)){}, यहाँ एक देखता है कि डी गोल्फिंग में खराब क्यों है, एक ;खाली बयान के रूप में उपयोग नहीं किया जा सकता है ।

— जाकारी
स्रोत

2

पर्ल 6 , 41 37 बाइट्स

{+(1...(^$_+*)>>.is-prime eqv!<<^$_)}

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

व्याख्या

{                                   }  # Block taking n as $_
   1...   # Sequence 1,2,... until
       (^$_+*)  # Range [i,i+n)
              >>.is-prime  # is-prime for each
                          eqv!<<^$_  # Equals (True,False,False,False,...)?
 +(                                )  # Length of sequence

— nwellnhof
स्रोत

1

QBIC , 28 बाइट्स

{~µs||~s-r>=:|_Xr\r=s]]s=s+1

व्याख्या

{         DO
~µs||     IF s is prime THEN (note, s starts as 3)
~s-r>=:   IF the gap between s (current prime) and r (prev prime) is big enough
|_Xr      THEN QUIT, printing prev prime r
\r=s      ELSE (gap too small, but s is prime), set r to prime s
]]        END IF x2, leaving us in the WHILE
s=s+1     increment s, retest for primality ...

— steenbergh
स्रोत

1

05AB1E , 9 बाइट्स

∞<ØD¥I@Ïн

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें । (टेस्ट सूट में अंतिम दो परीक्षण मामले शामिल नहीं हैं, क्योंकि उन लोगों के लिए TIO बार बाहर हैं।)

चूँकि अन्य प्रश्न इस एक के रूप में बंद है , मैं अपना उत्तर यहाँ भी पोस्ट कर रहा हूँ ।

स्पष्टीकरण:

∞           # Get an infinite list in the range [1, ...]
 <          # Decrease it by one to make it in the range [0, ...]
  Ø         # Get for each the (0-indexed) n'th prime: [2,3,5,7,11,...]
   D        # Duplicate this list of primes
    ¥       # Get all deltas (difference between each pair): [1,2,2,4,2,...]
     I@     # Check for each if they are larger than or equal to the input
            #  i.e. 4 → [0,0,0,1,0,1,0,1,1,0,...]
       Ï    # Only keep the truthy values of the prime-list
            #  → [23,31,47,53,61,...]
        н   # And keep only the first item (which is output implicitly)
            #  → 23

— केविन क्रूज़सेन
स्रोत

1

जावा 8, 99 92 बाइट्स

n->{int a=2,b=3,f,k;for(;b-a<n;)for(f=0,a=b;f<2;)for(f=++b,k=2;k<f;)f=f%k++<1?0:f;return a;}

इसे ऑनलाइन आज़माएं। (सबसे बड़े परीक्षण के मामले को बाहर रखा गया है, क्योंकि यह TIO में कई बार सामने आता है।)

स्पष्टीकरण:

n->{               // Method with integer as both parameter and return-type
  int a=2,b=3,     //  Prime-pair `a,b`, starting at 2,3
      f,           //  Prime-checker flag `f`, starting uninitialized
      k;           //  Temp integer, starting uninitialized
  for(;b-a         //  Loop as long as the difference between the current pair of primes
          <n;)     //  is smaller than the input
    for(f=0,       //   (Re)set the prime-checker flag to 0
        a=b;       //   Replace `a` with `b`, since we're about to search for the next prime-pair
        f<2;)      //   Inner loop as long as the prime-checker flag is still 0 (or 1)
                   //   (which means the new `b` is not a prime)
      for(f=++b,   //    Increase `b` by 1 first, and set this value to the prime-checker flag
          k=2;     //    Set `k` to 2
          k<f;)    //    Inner loop as long as `k` is still smaller than the prime-checker flag
        f=         //     Change the prime-checker flag to:
          f%k++<1? //      If the prime-checker flag is divisible by `k`
           0       //       Set the prime-checker flag to 0
          :        //      Else:
           f;      //       Leave it unchanged
                   //    (If any integer `k` in the range [2, `b`) can evenly divide `b`,
                   //     the prime-checker flag becomes 0 and the loop stops)
  return a;}       //  And finally after all the nested loops, return `a` as result

— केविन क्रूज़सेन
स्रोत

1

साफ , 33 बाइट्स

{x:({v:⊟v<=-x}↦primes+2)@0@0}

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

या, 28 चार्ट / 34 बाइट्स: {x:({v:⊟v≤-x}↦primes+2)@0@0}

मैं इसे एक समतुल्य, ASCII समतुल्य का उपयोग करके समझाऊंगा:

{x:({v:(-)over v<=-x}from primes+2)@0@0}
{x:                                    }    lambda w/ parameter `x`
                          primes+2          overlapping pairs of primes
                                            [[2, 3], [3, 5], [5, 7], ...]
    {v:             }from                   select prime pairs `v = [a, b]`...
       (-)over v                            ...where `a` - `b`...
                <=-x                        is <= `x`
   (                              )@0@0     select the first element of the first pair

— कोनोर ओ ब्रायन
स्रोत

1

एपीएल (एनएआरएस), 36 चार, 72 बाइट्स

∇r←h w;k
r←2
→0×⍳w≤r-⍨k←1πr⋄r←k⋄→2
∇

1 next फ़ंक्शन "अगला प्राइम" है; परीक्षा:

  h¨1 2 3 4 6 10 16 17 18 30 50 100 200
2 3 7 7 23 113 523 523 523 1327 19609 370261 20831323

— RosLuP
स्रोत

प्राइम गैप का पता लगाएं

चुनौती

सशर्त नियम

परीक्षण के मामलों

गैया , 6 बाइट्स

व्याख्या

जेली , 10, 9, 8 10 बाइट्स

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

मैथेमेटिका, 35 बाइट्स

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

हास्केल , 106 102 93 77 73 72 बाइट्स

पायथ - 14 बाइट्स

पॉवरशेल , 97 96 91 बाइट्स

भूसी , १३ ११ १० बाइट्स

मैथेमेटिका, 39 बाइट्स

33 बाइट संस्करण (मान्य नहीं है क्योंकि यह केवल 65535 वें प्राइम तक जाता है)

पायथन 2 , 96 88 बाइट्स

पर्ल 6 , 63 बाइट्स

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

आर + जीएमपी, 55 बाइट्स

रूबी , 61 बाइट्स

सी = 141 109 बाइट्स; सी ++, डी = 141 बाइट्स; सी #, जावा = 143 बाइट्स

डी, 127 125 122 बाइट्स

कैसे?

पर्ल 6 , 41 37 बाइट्स

व्याख्या

QBIC , 28 बाइट्स

व्याख्या

05AB1E , 9 बाइट्स

जावा 8, 99 92 बाइट्स

साफ , 33 बाइट्स

एपीएल (एनएआरएस), 36 चार, 72 बाइट्स