Un gap primo è la differenza tra due numeri primi consecutivi. Più specificamente, se p e q sono numeri primi con p < q e p +1, p +2, ..., q −1 non sono numeri primi, i numeri primi p e q definiscono un gap di n = q - p . Si dice che il divario sia iniziato da p e abbia lunghezza n .

È noto che esistono lacune prime arbitrariamente grandi. Cioè, dato n esiste un gap principale di lunghezza n o maggiore. Tuttavia, un gap primo di lunghezza esattamente n potrebbe non esistere (ma ne esisterà uno maggiore).

La sfida

Dato un numero intero positivo n, genera il primo numero primo che inizia uno spazio di lunghezza no maggiore.

Ad esempio, per l'input 4l'output dovrebbe essere 7, perché 7 e 11 sono i primi primi consecutivi che differiscono di almeno 4 (i gap precedenti sono 1, da 2 a 3; 2, da 3 a 5; e 2, da 5 a 7). Per l'input 3dovrebbe essere 7presente anche la risposta (non vi sono spazi vuoti di lunghezza 3).

Regole Adizionali

• L'algoritmo dovrebbe teoricamente funzionare in modo arbitrariamente alto n. In pratica, è accettabile se il programma è limitato da tempo, memoria o dimensione del tipo di dati.

• Input e output possono essere presi con qualsiasi mezzo ragionevole .

• Programmi o funzioni sono consentiti, in qualsiasi linguaggio di programmazione . Sono vietate le scappatoie standard .

• Vince il codice più breve in byte.

Casi test

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ṅọ⊃∆ṇ

Questo è estremamente inefficiente (il 16caso di test ha impiegato più di un'ora per il calcolo sulla mia macchina).

Provalo online!

Spiegazione

La sequenza sembra avere la proprietà che 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.

Gelatina , 10, 9, 8 10 byte

Æn_$:ð1#»2

Provalo online!

Due byte salvati grazie a @Dennis! (e quindi aggiunto di nuovo a causa di casi limite)

Spiegazione:

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

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

Provalo online!

Mathematica, 35 byte

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

Provalo online!

Mathematica, 77 byte

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

Haskell , 106 102 93 77 73 72 byte

Questo genera prima un elenco infinito di numeri primi, quindi cerca gli spazi vuoti primi. L'elenco principale è stato preso da qui . Probabilmente può essere abbreviato, ma non ho ancora capito :)

Grazie a @BruceForte per -4 byte e @Zgrab per -1 byte!

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

Provalo online!

Pyth - 14 byte

Filtra da [1, inf), filtrando per primalità ( P_) e che il primo primo filtrato da (n, inf), ha un diverso> = sull'input.

f&P_T<tQ-fP_Yh

Test Suite .

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

Provalo online!

Prende input $n, imposta $ae $buguale a 2, quindi entra in un forciclo infinito . Dentro, ci ripetiamo fino $bal prossimo primo . Quindi controlliamo se $b-$a(vale a dire, il divario) è più o meno -gadatto ea $n. Se lo è, produciamo $ae exit. Altrimenti impostiamo $adi essere $be incrementare $be iniziare la nostra prossima ricerca.

Avviso: questo è lento per input di grandi dimensioni. In effetti, non è possibile completare i 50test o superiori entro il timeout degli anni '60 su TIO. Oh bene.

Buccia , 13 11 10 byte

´ȯ!V≥⁰Ẋ-İp

Provalo online!

´       İ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 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])&

Versione a 33 byte (non valida perché arriva solo al 65535 ° primo)

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

Python 2 , 96 88 byte

- 8 byte Grazie a @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]

Provalo online!

Perl 6 , 63 byte

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

Provalo online!

Mathematica, 37 byte

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

Functioncon il primo argomento g. A partire da 2, applica la funzione p=NextPrimeripetutamente finché p@#-#<g&dà True(lo spazio tra il primo corrente e il primo successivo è inferiore a g).

R + gmp, 55 byte

Utilizza la funzione nextprime dalla libreria gmp

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

Rubino , 61 byte

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

Provalo online!

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

ATTENZIONE : ALGORITMO A BASSE PRESTAZIONI

Questo codice non è stato in grado di calcolare il gap principale per g(200)10 minuti. Per g(100), sono stati necessari 10 secondi (versione C ++)

Versione C ++ e 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;}

Versione C # e 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;}

Versione C, -32 byte grazie a ceilingcat:

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

Differenze tra la versione C # / Java e C / C ++ / D: !p(n)<==>p(n)==0

D, 127 125 122 byte

ATTENZIONE: ALGORITMO A BASSE PRESTAZIONI !!

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

Provalo online!

Come?

HatsuPointerKun di nuovo, ma farò la stregoneria specifica D.

• Il sistema modello può inferire i tipi T p(T)(T d)ed è più corto di C ++
• r=d%i++<1||r, Shenanigans D specifici, potrebbero funzionare in C / C ++, ma non lo so.
• p(++n), come sopra, non sono sicuro che funzioni in C / C ++
• while(p(++n)){}, qui si vede perché D non è bravo a giocare a golf, non si può usare ;come un'istruzione vuota.

Perl 6 , 41 37 byte

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

Provalo online!

Spiegazione

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

Spiegazione

{         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@Ïн

Provalo online o verifica tutti i casi di test . (Test Suite non contiene gli ultimi due casi di test, perché TIO scade per quelli.)

Poiché l'altra domanda è chiusa come una copia di questa , sto postando la mia risposta anche qui.

Spiegazione:

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

Provalo online. (Il più grande caso di test è escluso, perché scade in TIO.)

Spiegazione:

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

Ordinato , 33 byte

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

Provalo online!

Oppure, 28 caratteri / 34 byte: {x:({v:⊟v≤-x}↦primes+2)@0@0}

Spiegherò questo usando un equivalente ASCII equivalente:

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

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

1π è la funzione "prossimo primo"; test:

  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