ช่องว่างที่สำคัญคือความแตกต่างระหว่างสองช่วงเวลาติดต่อกัน โดยเฉพาะอย่างยิ่งถ้าPและQเป็นช่วงเวลาที่มีP < QและP 1, P 2, ... , คิว -1 ไม่ได้เฉพาะที่เฉพาะPและQกำหนดช่องว่างของn = Q - พี ช่องว่างกล่าวคือจะต้องเริ่มต้นจากหน้าและจะมีความยาว n

เป็นที่ทราบกันดีว่ามีช่องว่างขนาดใหญ่ที่ใหญ่มาก นั่นคือเนื่องจากnมีช่องว่างที่สำคัญของความยาวnหรือใหญ่กว่า อย่างไรก็ตามช่องว่างที่สำคัญของความยาวnแน่นอนอาจไม่มีอยู่ (แต่จะมีขนาดใหญ่กว่า)

ความท้าทาย

กำหนดจำนวนเต็มบวกnเอาท์พุทไพรม์แรกที่เริ่มต้นช่องว่างความยาวnหรือใหญ่กว่า

ตัวอย่างเช่นสำหรับอินพุต4เอาต์พุตควรเป็น7เพราะ 7 และ 11 เป็นช่วงเวลาที่ต่อเนื่องกันครั้งแรกที่แตกต่างกันอย่างน้อย 4 (ช่องว่างก่อนหน้าคือ 1 จาก 2 ถึง 3; 2, จาก 3 ถึง 5 และ 2 จาก 5 7) สำหรับ3คำตอบที่ป้อนควรเป็น7(ไม่มีช่องว่างความยาว 3)

กฎ Aditional

• nอัลกอริทึมในทางทฤษฎีควรจะทำงานให้สูงโดยพลการ ในทางปฏิบัติเป็นที่ยอมรับได้หากโปรแกรมถูก จำกัด ด้วยเวลาหน่วยความจำหรือขนาดข้อมูลชนิด

• input และ output สามารถนำมาโดยใด ๆวิธีการที่เหมาะสม

• โปรแกรมหรือฟังก์ชั่นที่ได้รับอนุญาตในการเขียนโปรแกรมภาษา ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม

• รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

กรณีทดสอบ

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

Gaiaขนาด 6 ไบต์

zṅọ⊃∆ṇ

กรณีนี้ไม่มีประสิทธิภาพอย่างยิ่ง ( 16กรณีทดสอบใช้เวลาในการคำนวณบนเครื่องของฉันมากกว่าหนึ่งชั่วโมง)

ลองออนไลน์!

คำอธิบาย

ลำดับที่ดูเหมือนว่าจะมีทรัพย์สินที่A (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.

เยลลี่ , 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

Mathematica ขนาด 30 ไบต์

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

ลองออนไลน์!

Mathematica, 35 ไบต์

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

ลองออนไลน์!

Mathematica, 77 ไบต์

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

Haskell , 106 102 93 77 73 72 ไบต์

สิ่งนี้จะสร้างรายการช่วงเวลาที่ไม่มีที่สิ้นสุดก่อนแล้วจึงค้นหาช่องว่างที่สำคัญ รายการที่สำคัญถูกนำมาจากที่นี่ มันอาจจะสั้นลง แต่ฉันยังไม่เข้าใจวิธี :)

ขอบคุณ @BruceForte สำหรับ -4 ไบต์และ @Zgrab สำหรับ -1 ไบต์!

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

ลองออนไลน์!

Pyth - 14 ไบต์

มันกรองจาก [1, inf), กรองโดย primality ( P_) และตัวกรองสำคัญตัวถัดไปที่กรองจาก (n, inf) นั้นมีค่า>> ที่แตกต่างกันไป

f&P_T<tQ-fP_Yh

Test Suite

PowerShell , 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(เช่นช่องว่าง) เป็น-greaterthanor equal $nไป ถ้าเป็นเราเอาท์พุทและ$a exitมิฉะนั้นเราจะกำหนด$aให้เป็น$bและเพิ่มขึ้น$bและเริ่มต้นการค้นหาต่อไปของเรา

คำเตือน: สิ่งนี้ช้าสำหรับอินพุตขนาดใหญ่ ในความเป็นจริงมันไม่สามารถทำการ50ทดสอบที่เสร็จสมบูรณ์หรือสูงกว่าได้ในช่วงเวลา 60 วินาทีของ TIO โอ้ดี

Husk , 13 11 10 ไบต์

´ȯ!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

Mathematica ขนาด 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&

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

ลองออนไลน์!

Perl 6 , 63 ไบต์

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

ลองออนไลน์!

Mathematica ขนาด 37 ไบต์

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

Functiongกับอาร์กิวเมนต์แรก เริ่มต้นด้วย2ใช้ฟังก์ชั่นp=NextPrimeซ้ำ ๆ ตราบใดที่p@#-#<g&ให้True(ช่องว่างระหว่างนายกปัจจุบันและนายกรัฐมนตรีถัดไปน้อยกว่าg)

R + gmp, 55 ไบต์

ทำให้การใช้งานฟังก์ชั่นถัดไปจากห้องสมุด gmp

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

Ruby , 61 ไบต์

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

ลองออนไลน์!

C = 141 109 ไบต์; C ++, D = 141 ไบต์ C #, Java = 143 ไบต์

คำเตือน : ประสิทธิภาพการแสดงผลต่ำ

รหัสนี้ไม่สามารถคำนวณช่องว่างที่สำคัญได้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;}

รุ่น C # และ Java:

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;}

รุ่น C, -32 ไบต์ต้องขอบคุณ catcat:

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

D, 127 125 122 ไบต์

คำเตือน: ประสิทธิภาพการแสดงผลต่ำ !!

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 อีกครั้ง แต่ฉันจะทำเวทย์มนตร์เฉพาะ D

• ระบบเทมเพลตสามารถสรุปประเภทT p(T)(T d)และสั้นกว่า C ++
• r=d%i++<1||r, D shenanigans ที่เฉพาะเจาะจงอาจทำงานใน C / C ++ แต่ฉันไม่รู้
• p(++n)เช่นเดียวกับข้างต้นไม่แน่ใจว่าทำงานใน C / C ++ หรือไม่
• while(p(++n)){}นี่คือสิ่งที่เห็นว่าทำไม D ไม่ดีในการเล่นกอล์ฟและไม่สามารถใช้;เป็นคำสั่งที่ว่าง

Perl 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

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 ...

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

Java 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

เรียบร้อย 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

APL (NARS), 36 ถ่าน, 72 ไบต์

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

1πคือฟังก์ชัน "next prime"; ทดสอบ:

  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