Một khoảng cách chính là sự khác biệt giữa hai số nguyên tố liên tiếp. Cụ thể hơn, nếu p và q là các số nguyên tố có p < q và p +1, p +2, ..., q 1 không phải là số nguyên tố, các số nguyên tố p và q xác định khoảng cách n = q - p . Khoảng cách được cho là bắt đầu bởi p và có độ dài n .

Được biết, tồn tại những khoảng trống lớn tùy ý. Đó là, với n tồn tại một khoảng cách nguyên tố có chiều dài n hoặc lớn hơn. Tuy nhiên, một khoảng cách nguyên tố có độ dài chính xác n có thể không tồn tại (nhưng sẽ có một khoảng cách lớn hơn).

Các thách thức

Cho một số nguyên dương n, xuất ra số nguyên tố đầu tiên bắt đầu một khoảng cách có độ dài nhoặc lớn hơn.

Ví dụ, đối với đầu vào 4, đầu ra phải là 7, vì 7 và 11 là các số nguyên tố liên tiếp đầu tiên khác nhau ít nhất 4 (các khoảng trống trước đó là 1, từ 2 đến 3; 2, từ 3 đến 5; và 2, từ 5 đến 7). Đối với đầu vào 3, câu trả lời cũng phải có 7(không có khoảng trống có độ dài 3).

Quy tắc bổ trợ

• Các thuật toán nên hoạt động trên lý thuyết cho cao tùy ý n. Trong thực tế, có thể chấp nhận nếu chương trình bị giới hạn bởi thời gian, bộ nhớ hoặc kích thước loại dữ liệu.

• Đầu vào và đầu ra có thể được thực hiện bằng bất kỳ phương tiện hợp lý .

• Các chương trình hoặc chức năng được cho phép, trong bất kỳ ngôn ngữ lập trình . Sơ hở tiêu chuẩn bị cấm.

• Mã ngắn nhất trong byte thắng.

Các trường hợp thử nghiệm

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 byte

zṅọ⊃∆ṇ

Điều này cực kỳ không hiệu quả ( 16trường hợp thử nghiệm mất hơn một giờ để tính toán trên máy của tôi).

Hãy thử trực tuyến!

Giải trình

Chuỗi dường như có thuộc tính mà 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.

Jelly , 10, 9, 8 10 byte

Æn_$:ð1#»2

Hãy thử trực tuyến!

Hai byte được lưu nhờ @Dennis! (và sau đó thêm lại một lần nữa do các trường hợp cạnh)

Giải trình:

Æ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

Toán học, 30 byte

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

Hãy thử trực tuyến!

Toán học, 35 byte

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

Hãy thử trực tuyến!

Toán học, 77 byte

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

Haskell , 106 102 93 77 73 72 byte

Điều này tạo ra một danh sách vô hạn các số nguyên tố đầu tiên, sau đó tìm kiếm các khoảng trống chính. Danh sách chính được lấy từ đây . Nó có thể được rút ngắn, nhưng tôi chưa tìm ra cách nào :)

Cảm ơn @BruceForte cho -4 byte và @Zgrab cho -1 byte!

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

Hãy thử trực tuyến!

Pyth - 14 byte

Nó lọc từ [1, inf), lọc theo nguyên hàm ( P_) và nguyên tố tiếp theo được lọc từ (n, inf), có khác> = với đầu vào.

f&P_T<tQ-fP_Yh

Phòng thử nghiệm .

PowerShell , 97 96 91 byte

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

Hãy thử trực tuyến!

Lấy đầu vào $n, bộ $avà $bbằng 2, sau đó nhập một forvòng lặp vô hạn . Bên trong, chúng tôi lặp đi lặp lại $bcho đến khi chúng tôi đến thủ tướng tiếp theo . Sau đó, chúng tôi kiểm tra xem $b-$a(tức là khoảng cách) là -greaterthanor đủ điều kiện eđể $n. Nếu có, chúng tôi đầu ra $avà exit. Nếu không chúng ta thiết lập $ađược $bvà increment $bvà bắt đầu tìm kiếm tiếp theo của chúng tôi.

Cảnh báo: Đây là chậm cho đầu vào lớn. Trên thực tế, nó không thể hoàn thành các 50bài kiểm tra cao hơn hoặc cao hơn trong thời gian chờ 60 giây trên TIO. Ồ tốt

Husk , 13 11 10 byte

´ȯ!V≥⁰Ẋ-İp

Hãy thử trực tuyến!

´       İ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

Toán học, 39 byte

(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])&

Phiên bản 33 byte (không hợp lệ vì nó chỉ đi lên đến số nguyên tố 65535)

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

Python 2 , 96 88 byte

- 8 byte Nhờ @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]

Hãy thử trực tuyến!

Perl 6 , 63 byte

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

Hãy thử trực tuyến!

Toán học, 37 byte

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

Functionvới lập luận đầu tiên g. Bắt đầu với 2, áp dụng hàm p=NextPrimenhiều lần miễn là p@#-#<g&cho True(khoảng cách giữa số nguyên tố hiện tại và số nguyên tố tiếp theo nhỏ hơn g).

R + gmp, 55 byte

Sử dụng hàm nextprime từ thư viện gmp

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

Ruby , 61 byte

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

Hãy thử trực tuyến!

C = 141 109 byte; C ++, D = 141 byte; C #, Java = 143 byte

CẢNH BÁO : ALGORITHM HIỆU SUẤT THẤP

Mã này không thể tính được khoảng cách nguyên tố g(200)trong vòng 10 phút. Đối với g(100), nó cần 10 giây (phiên bản C ++)

Phiên bản C ++ và 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;}

Phiên bản C # và 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;}

Phiên bản C, -32 byte nhờ trần nhà:

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

Sự khác biệt giữa phiên bản C # / Java và C / C ++ / D: !p(n)<==>p(n)==0

D, 127 125 122 byte

CẢNH BÁO: ALGORITHM HIỆU SUẤT THẤP !!

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

Hãy thử trực tuyến!

Làm sao?

HatsuPulumKun một lần nữa, nhưng tôi sẽ thực hiện phép thuật cụ thể D.

• Hệ thống mẫu có thể suy ra các loại T p(T)(T d)và ngắn hơn C ++
• r=d%i++<1||r, Các shenanigans cụ thể, có thể hoạt động trong C / C ++, nhưng tôi không biết.
• p(++n), giống như trên, không chắc nó có hoạt động trong C / C ++ không
• while(p(++n)){}, ở đây người ta thấy tại sao D chơi golf không tốt, người ta không thể sử dụng ;như một tuyên bố trống rỗng.

Perl 6 , 41 37 byte

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

Hãy thử trực tuyến!

Giải trình

{                                   }  # 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 byte

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

Giải trình

{         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 byte

∞<ØD¥I@Ïн

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm . (Test Suite không chứa hai trường hợp thử nghiệm cuối cùng, vì TIO hết thời gian cho những trường hợp đó.)

Vì câu hỏi khác được đóng lại như một bản sao của câu hỏi này , tôi cũng đang đăng câu trả lời của mình ở đây.

Giải trình:

∞           # 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 byte

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

Hãy thử trực tuyến. (Trường hợp thử nghiệm lớn nhất được loại trừ, vì nó hết thời gian trong TIO.)

Giải trình:

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

Gọn gàng , 33 byte

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

Hãy thử trực tuyến!

Hoặc, 28 ký tự / 34 byte: {x:({v:⊟v≤-x}↦primes+2)@0@0}

Tôi sẽ giải thích điều này bằng cách sử dụng tương đương ASCII tương đương:

{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 char, 72 byte

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

1π là hàm "số nguyên tố tiếp theo"; kiểm tra:

  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