Una brecha principal es la diferencia entre dos primos consecutivos. Más específicamente, si p y q son primos con p < q y p +1, p +2, ..., q −1 no son primos, los primos p y q definen un espacio de n = q - p . Se dice que la brecha comienza por p , y tiene una longitud n .

Se sabe que existen brechas primarias arbitrariamente grandes. Es decir, dado n existe un espacio primario de longitud n o mayor. Sin embargo, es posible que no exista un espacio libre de longitud exactamente n (pero sí uno mayor)

El reto

Dado un entero positivo n, genera el primer primo que comienza un espacio de longitud no mayor.

Como ejemplo, para la entrada 4la salida debería ser 7, porque 7 y 11 son los primeros números primos consecutivos que difieren en al menos 4 (los espacios anteriores son 1, de 2 a 3; 2, de 3 a 5; y 2, de 5 a 7). Para la entrada, 3la respuesta también debe ser 7(no hay espacios de longitud 3).

Reglas adicionales

• El algoritmo debería funcionar teóricamente para arbitrariamente alto n. En la práctica, es aceptable si el programa está limitado por el tiempo, la memoria o el tamaño del tipo de datos.

• La entrada y la salida se pueden tomar por cualquier medio razonable .

• Se permiten programas o funciones , en cualquier lenguaje de programación . Las lagunas estándar están prohibidas.

• El código más corto en bytes gana.

Casos de prueba

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 bytes

zṅọ⊃∆ṇ

Esto es extremadamente ineficiente (el 16caso de prueba tomó más de una hora para calcular en mi máquina).

Pruébalo en línea!

Explicación

La secuencia parece tener la propiedad de que 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 bytes

Æn_$:ð1#»2

Pruébalo en línea!

¡Dos bytes guardados gracias a @Dennis! (y luego se volvió a agregar debido a casos extremos)

Explicación:

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

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

Pruébalo en línea!

Mathematica, 35 bytes

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

Pruébalo en línea!

Mathematica, 77 bytes

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

Haskell , 106102 93 77 73 72 bytes

Esto genera una lista infinita de primos primero, luego busca las brechas principales. La lista principal fue tomada de aquí . Probablemente se puede acortar, pero aún no he descubierto cómo :)

¡Gracias a @BruceForte por -4 bytes y @Zgrab por -1 byte!

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

Pruébalo en línea!

Pyth - 14 bytes

Filtra desde [1, inf), filtra por primality ( P_) y que el siguiente primo filtrado desde (n, inf), tiene un valor diferente> = a la entrada.

f&P_T<tQ-fP_Yh

Test Suite .

PowerShell , 97 96 91 bytes

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

Pruébalo en línea!

Toma entrada $n, establece $ae $bigual a 2, luego ingresa un forbucle infinito . En el interior, seguimos adelante $bhasta llegar al próximo prime . Entonces, comprobamos si $b-$a(es decir, la brecha) es -greaterthanor equal a $n. Si es así, sacamos $ay exit. De lo contrario, establecemos $aser $be incrementar $be iniciar nuestra próxima búsqueda.

Advertencia: Esto es lento para entradas grandes. De hecho, no puede completar las 50pruebas o más altas dentro del tiempo de espera de 60 en TIO. Oh bien.

Casco , 13 11 10 bytes

´ȯ!V≥⁰Ẋ-İp

Pruébalo en línea!

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

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

Versión de 33 bytes (no válida porque solo sube a la 65535ª prima)

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

Python 2 , 96 88 bytes

- 8 bytes Gracias 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]

Pruébalo en línea!

Perl 6 , 63 bytes

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

Pruébalo en línea!

Mathematica, 37 bytes

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

Functioncon el primer argumento g. Comenzando con 2, aplica la función p=NextPrimerepetidamente siempre que se p@#-#<g&dé True(la brecha entre el cebado actual y el próximo cebado es menor que g).

R + gmp, 55 bytes

Utiliza la función nextprime de la biblioteca gmp

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

Ruby , 61 bytes

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

Pruébalo en línea!

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

ADVERTENCIA : ALGORITMO DE BAJO RENDIMIENTO

Este código no pudo calcular la brecha principal g(200)en 10 minutos. porg(100) , necesitó 10 segundos (versión C ++)

Versión C ++ y 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 # y versión de 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;}

Versión C, -32 bytes gracias 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;}

Diferencias entre la versión C # / Java y C / C ++ / D: !p(n)<==>p(n)==0

D, 127 125 122 bytes

ADVERTENCIA: ¡ALGORITMO DE BAJO RENDIMIENTO!

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

Pruébalo en línea!

¿Cómo?

HatsuPointerKun nuevamente, pero haré la hechicería específica de D.

• El sistema de plantillas puede inferir tipos T p(T)(T d) , y es más corto que C ++
• r=d%i++<1||r, D travesuras específicas, podrían funcionar en C / C ++, pero no lo sé.
• p(++n), igual que el anterior, no estoy seguro si funciona en C / C ++
• while(p(++n)){}, aquí se ve por qué D es malo jugando al golf, no se puede usar ;como una declaración vacía.

Perl 6 , 41 37 bytes

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

Pruébalo en línea!

Explicación

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

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

Explicación

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

∞<ØD¥I@Ïн

Pruébelo en línea o verifique todos los casos de prueba . (Test Suite no contiene los dos últimos casos de prueba, porque TIO agota el tiempo para esos).

Como la otra pregunta está cerrada como un engaño de esta , estoy publicando mi respuesta aquí también.

Explicación:

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

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

Pruébalo en línea. (Se excluye el caso de prueba más grande, porque se agota el tiempo en TIO)

Explicación:

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

Ordenado , 33 bytes

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

Pruébalo en línea!

O 28 caracteres / 34 bytes: {x:({v:⊟v≤-x}↦primes+2)@0@0}

Explicaré esto 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 caracteres, 72 bytes

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

1π es la función "próximo primo"; prueba:

  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