Un écart premier est la différence entre deux nombres premiers consécutifs. Plus précisément, si p et q sont des nombres premiers avec p < q et p +1, p +2, ..., q −1 ne sont pas des nombres premiers, les nombres premiers p et q définissent un écart de n = q - p . L'écart est dit être commencé par p et avoir une longueur n .

On sait qu'il existe des écarts premiers arbitrairement importants. C'est-à-dire, étant donné n, il existe un intervalle principal de longueur n ou plus. Cependant, un intervalle principal de longueur exactement n peut ne pas exister (mais un plus grand le sera).

Le défi

Étant donné un entier positif n, sortez le premier nombre premier qui commence un intervalle de longueur nou plus.

Par exemple, pour l'entrée, 4la sortie devrait être 7, car 7 et 11 sont les premiers nombres premiers consécutifs qui diffèrent d'au moins 4 (les écarts précédents sont 1, de 2 à 3; 2, de 3 à 5; et 2, de 5 à 7). Pour la saisie, 3la réponse doit également être 7(il n'y a pas de lacunes de longueur 3).

Règles supplémentaires

• L'algorithme devrait théoriquement fonctionner pour des valeurs arbitrairement élevées n. En pratique, cela est acceptable si le programme est limité par le temps, la mémoire ou la taille du type de données.

• L'entrée et la sortie peuvent être prises par tout moyen raisonnable .

• Les programmes ou fonctions sont autorisés, dans n'importe quel langage de programmation . Les failles standard sont interdites.

• Le code le plus court en octets gagne.

Cas de 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 octets

zṅọ⊃∆ṇ

C'est extrêmement inefficace (le 16cas de test a pris plus d'une heure à calculer sur ma machine).

Essayez-le en ligne!

Explication

La séquence semble avoir la propriété 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.

Gelée , 10, 9, 8 10 octets

Æn_$:ð1#»2

Essayez-le en ligne!

Deux octets enregistrés grâce à @Dennis! (puis ajouté à nouveau en raison de bordures)

Explication:

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

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

Essayez-le en ligne!

Mathematica, 35 octets

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

Essayez-le en ligne!

Mathematica, 77 octets

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

Haskell , 106 102 93 77 73 72 octets

Cela génère d'abord une liste infinie de nombres premiers, puis recherche les écarts premiers. La liste principale a été prise d' ici . Il peut probablement être raccourci, mais je n'ai pas encore compris comment :)

Merci à @BruceForte pour -4 octets et @Zgrab pour -1 octet!

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

Essayez-le en ligne!

Pyth - 14 octets

Il filtre à partir de [1, inf), filtrant par primalité ( P_) et que le prochain nombre premier filtré à partir de (n, inf), a un différent = = à l'entrée.

f&P_T<tQ-fP_Yh

Suite de tests .

PowerShell , 97 96 91 octets

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

Essayez-le en ligne!

Prend l'entrée $n, définit $aet est $bégal à 2, puis entre dans une forboucle infinie . À l'intérieur, nous bouclons jusqu'à $bce que nous arrivions au premier prime . Ensuite , nous vérifions si $b-$a(c. -à l'écart) est -greaterthanor equal à $n. Si c'est le cas, nous sortons $aet exit. Sinon, nous définissons $aêtre $bet incrémenter $bet commencer notre prochaine recherche.

Avertissement: Ceci est lent pour une entrée volumineuse. En fait, il ne peut pas terminer les 50tests ou plus dans le délai d'expiration des années 60 sur TIO. Tant pis.

Husk , 13 11 10 octets

´ȯ!V≥⁰Ẋ-İp

Essayez-le en ligne!

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

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

Version 33 octets (non valide car elle ne monte qu'au 65535th prime)

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

Python 2 , 96 88 octets

- 8 octets Merci à @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]

Essayez-le en ligne!

Perl 6 , 63 octets

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

Essayez-le en ligne!

Mathematica, 37 octets

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

Functionavec le premier argument g. En commençant par 2, applique la fonction à p=NextPrimeplusieurs reprises aussi longtemps que p@#-#<g&donne True(l'écart entre le nombre premier actuel et le nombre premier suivant est inférieur à g).

R + gmp, 55 octets

Utilise la fonction nextprime de la bibliothèque gmp

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

Rubis , 61 octets

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

Essayez-le en ligne!

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

AVERTISSEMENT : ALGORITHME DE FAIBLE PERFORMANCE

Ce code n'a pas pu calculer l'écart principal pendant g(200)10 minutes. Pour g(100), il fallait 10 secondes (version C ++)

Version C ++ et 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;}

Version C # et 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;}

Version C, -32 octets grâce à plafondcat:

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

Différences entre la version C # / Java et C / C ++ / D: !p(n)<==>p(n)==0

D, 127 125 122 octets

ATTENTION: ALGORITHME DE FAIBLE PERFORMANCE !!

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

Essayez-le en ligne!

Comment?

HatsuPointerKun à nouveau, mais je vais faire la sorcellerie spécifique D.

• Le système de modèles peut déduire des types T p(T)(T d)et est plus court que C ++
• r=d%i++<1||r, Les manigances spécifiques à D, pourraient fonctionner en C / C ++, mais je ne sais pas.
• p(++n), comme ci-dessus, je ne sais pas si cela fonctionne en C / C ++
• while(p(++n)){}, on voit ici pourquoi D est mauvais au golf, on ne peut pas l'utiliser ;comme une déclaration vide.

Perl 6 , 41 37 octets

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

Essayez-le en ligne!

Explication

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

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

Explication

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

∞<ØD¥I@Ïн

Essayez-le en ligne ou vérifiez tous les cas de test . (Test Suite ne contient pas les deux derniers cas de test, car TIO arrive à expiration pour ceux-ci.)

Puisque l'autre question est fermée en tant que dupe de celle-ci , je poste également ma réponse ici.

Explication:

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

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

Essayez-le en ligne. (Le plus grand cas de test est exclu, car il expire dans TIO.)

Explication:

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

Tidy , 33 octets

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

Essayez-le en ligne!

Ou, 28 caractères / 34 octets: {x:({v:⊟v≤-x}↦primes+2)@0@0}

Je vais expliquer cela en utilisant un équivalent ASCII équivalent:

{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 caractères, 72 octets

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

1π est la fonction "prochain premier"; tester:

  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