Encuentra lagunas principales


27

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


Por pq te refieres a qp ¿verdad?
Erik the Outgolfer

@EriktheOutgolfer Sí; corregido, gracias!
Luis Mendo


OEIS A002386 (Relacionado)
Stephen

Respuestas:


3

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.

9

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

¿Sabemos con certeza que el resultado siempre será mayor que o igual a la entrada? ( #contaré desde la entrada aquí) Parece razonable suponer esto, pero por mi parte no tengo idea si es una suposición válida. EDITAR: FYI para arreglar (si es necesario) el prefijo con
Jonathan Allan

55
El postulado de @JonathanAllan Bertrand implica que la brecha de un primo es estrictamente menor que el primo en sí.
Dennis

@Dennis brillante muchas gracias! TMYK ...
Jonathan Allan

4

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

Inteligente inteligente ... que ni siquiera necesita para asegurarse de que tanto py qson primos ... El primer código parece válida, sin embargo, ya que sólo llega hasta 65535 a menos que alimentar de forma explícita el argumento MaxIterations.
JungHwan Min

Además, -2 bytes para la versión de 35 bytes:(For[t=2,NextPrime@t-t<#,t++];t)&
JungHwan Min

4

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!


Por supuesto que hay algo de magia de mónada, gracias :)
error

zip=<<tail$[...]Guarda un byte.
Zgarb

"Esto genera una lista infinita de primos primero, luego ...": bueno, ¿entonces nunca debería suceder? (es decir, solo sucederá después de un tiempo infinitamente largo, el tiempo para "generar primero" una lista infinita de primos)
Olivier Dulac

1
Haskell utiliza una evaluación diferida, por lo que solo se generan tantas entradas de esa lista como se utilizan realmente. Entonces esos números primos se generan hasta el punto en el que realmente encontramos los puntos. Si lo intentas, verás que, para cualquiera n, se detendrá después de un período de tiempo finito :) (Haskell no es un procedimiento, sino un lenguaje funcional con evaluación perezosa.)
error

1
Bueno, es una lista infinita, por definición no tiene un final. Lo que describí es exactamente lo que sucede debajo del capó en los intérpretes habituales, ¡pero eso no se especifica como parte del lenguaje, por lo que no se puede decir eso!
flawr

3

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 .


3

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.


3

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

3

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&



2

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&True(la brecha entre el cebado actual y el próximo cebado es menor que g).


2

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)

Necesitas agregar cat(s)al final. La impresión implícita no funciona en programas completos.
JAD


2

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


Puede revertir return 0; return 1y eliminar el !antesp(++n)
ceilingcat

d%i==0y !(d%i)puede ser d%i<0. Además, el uso sistema de plantillas D's la solución en D puede ser: T p(T)(T d){for(T i=2;i<=d/2;++i)if(d%i<1)return 0;return 1;}T g(T)(T d){T f=2,n=3;while(n-f<d){f=n;do++n;while(!p(n));}return f;. (La eliminación de llaves después del fory también dopodría aplicarse a C ++)
Zacharý

Publiqué la versión D separada, que utiliza trucos específicos de D que no se pueden encontrar en C / C ++ / C # / Java.
Zacharý

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;}<- eso debería funcionar para la versión C ++
Zacharý

2

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.

2

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

1

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

1

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

1

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

1

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

1

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  
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.