一个主要的差距是连续两个素数之差。更具体地，如果p和q是p＜q且p +1，p +2，...，q -1不是素数的素数，则素数p和q定义了n = q - p的间隔。的间隙被认为是开始由p，并具有长度 Ñ。

已知存在任意大的主要间隙。即，给定n，则存在长度为n或更大的素数间隙。但是，可能不存在长度恰好为n的素数间隙（但会更大）。

挑战

给定一个正整数n，输出第一个素数，该素数开始于length 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

盖亚（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&]]&

哈斯克尔，106102 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

测试套件。

PowerShell，97 96 91字节

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

在线尝试！

接受input $n，set $a和$b等于2，然后进入无限for循环。在内部，我们不断循环$b直到到达下一个素数。然后我们检查$b-$a（即间隙）是-greaterthanor e资格赛来$n。如果是，我们输出$a和exit。否则，我们将其设置$a为$b和$b并开始下一个搜索。

警告：这对于大输入来说很慢。实际上，它无法50在TIO的60秒超时时间内完成或更高测试。那好吧。

外壳，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&]

Function第一个论点g。从开始2，p=NextPrime只要p@#-#<g&给定，就会重复应用功能True（当前素数和下一个素数之间的差距小于g）。

R + gmp，55个字节

利用gmp库中的nextprime函数

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

红宝石，61字节

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

在线尝试！

C = 141109字节; 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版本，由于ceilingcat，-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

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特定的恶作剧，可能在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π是函数“下一个素数”；测试：

  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