주요 차이는 두 개의 연속 소수의 차이입니다. 보다 구체적으로, p 및 q 가 p < q 이고 p +1, p +2, ..., q -1이 소수 인 경우, 소수 p 및 q 는 n = q - p 의 간격을 정의합니다 . 간격은 p 에 의해 시작 되고 길이 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테스트 케이스는 컴퓨터에서 계산하는 데 1 시간 이상 걸렸습니다).

온라인으로 사용해보십시오!

설명

시퀀스에는 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 덕분에 2 바이트가 절약되었습니다! (가장자리로 인해 다시 추가됨)

설명:

Æ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 바이트

이를 통해 무한의 소수 목록을 먼저 생성 한 다음 소수 간격을 찾습니다. 주요 목록은 여기 에서 가져 왔습니다 . 아마 단축 될 수는 있지만 아직 방법을 찾지 못했습니다.)

-4 바이트의 경우 @BruceForte와 -1 바이트의 경우 @Zgrab 덕분입니다!

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

온라인으로 사용해보십시오!

입력 취하고 $n, 세트 $a와 $b동일한 2다음 무한대 들어간다 for루프. 내부 에서 다음 프라임에 도달 할$b 때까지 계속 반복합니다 . 그런 다음 (즉, 간격)이 reaterthanor qual인지 확인합니다 . 이 경우, 우리는 출력 과 . 그렇지 않으면 우리는 설정 으로 하고 증가 하고 우리의 다음 검색을 시작합니다.$b-$a-ge$n$aexit$a$b$b

경고 : 큰 입력 에서는 느립니다 . 실제로 50TIO에서 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&

파이썬 2 , 96 88 바이트

-@ Maltysen 덕분에 8 바이트

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]

온라인으로 사용해보십시오!

펄 6 , 63 바이트

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

온라인으로 사용해보십시오!

수학, 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||rD 특정 shenanigans는 C / C ++에서 작동 할 수 있지만 잘 모르겠습니다.
• p(++n)위와 동일하지만 C / C ++에서 작동하는지 확실하지 않습니다.
• while(p(++n)){}, 여기 D는 왜 골프에 나쁜지 ;, 빈 문장으로 사용할 수없는 이유를 알 수 있습니다 .

펄 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가 시간 초과되기 때문에 Test Suite에는 마지막 두 테스트 사례가 포함되어 있지 않습니다.

이후 다른 질문이 하나의 잘 속는 사람으로 닫혀 , 나는 게시하도록하겠습니다 내 대답을 뿐만 아니라 여기에.

설명:

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

자바 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