Lo sé, lo sé, otro desafío más ...

Relacionado

Un primer solitaria (o aislado) es un número primo ptal que p-2, p+2, p-4, p+4... p-2k, p+2kpara algunos kson todo compuesto. Llamamos a tal primo un kprimo aislado en tiempos.

Por ejemplo, una prima 5a vez aislada es 211, ya que todas 201, 203, 205, 207, 209, 213, 215, 217, 219, 221son compuestas. ( p-2*5=201, p-2*4=203, Etc.)

Desafío

Dados dos enteros de entrada n > 3y k > 0salida, el kprimo aislado más pequeño que es estrictamente mayor que n.

Por ejemplo, para k = 5y nen cualquier rango 4 ... 210, la salida debería ser 211, ya que es el primo aislado 5to veces más pequeño estrictamente más grande que la entrada n.

Ejemplos

n=55 k=1
67

n=500 k=1
503

n=2100 k=3
2153

n=2153 k=3
2161

n=14000 k=7
14107

n=14000 k=8
14107

Reglas

• Si corresponde, puede suponer que la entrada / salida se ajustará al tipo entero nativo de su idioma.
• La entrada y la salida se pueden dar por cualquier método conveniente .
• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

Jalea , 17 13 bytes

_æR+⁼ḟ
‘ç1#Ḥ}

Pruébalo en línea!

Cómo funciona

‘ç1#Ḥ}  Main link. Left argument: n. Right argument: k

‘       Increment; yield n+1.
    Ḥ}  Unhalve right; yield 2k.
 ç1#    Call the helper link with arguments m = n+1, n+2, ... and k until 1 one
        them returns a truthy value. Return the matching [m].


_æR+⁼ḟ  Helper link. Left argument: m. Right argument: k

_       Subtract; yield m-2k.
   +    Add; yield m+2k.
 æR     Prime range; yield the array of primes in [m-2k, ..., m+2k].
     ḟ  Filterfalse; yield the elements of [m] that do not occur in [k], i.e., [m]
        if m ≠ 2k and [] otherwise.
        The result to the left will be non-empty when m = 2k, as there always is
        a prime in [0, ..., 2m], since m > n > 3.
    ⁼   Test the results to both sides for equality.
        This yields 1 iff m is the only prime in [m-2k, ..., m+2k].

Casco , 13 bytes

ḟ§=;ofṗM+ṡD⁰→

Pruébalo en línea!

Explicación

Muy claro.

ḟ§=;ofṗM+ṡD⁰→  Inputs are k and n.
            →  Increment n
ḟ              and find the first number m >= n+1 such that:
         ṡD⁰    Take symmetric range [-2k,..,2k].
       M+       Add m to each.
    ofṗ         Keep those that are prime.
 §=             Check equality with
   ;            the singleton [m].

Java 8, 144 143 bytes

(n,k)->{for(k*=2;;)if(p(++n)>1){int i=-k;for(;i<=k&p(n+i)<2|i==0;i+=2);if(i>k)return n;}}int p(int n){for(int i=2;i<n;n=n%i++<1?0:n);return n;}

Explicación:

Pruébalo en línea.

(n,k)->{                      // Method with two integer parameters and integer return-type
  for(k*=2;                   //  Multiply `k` by 2
      ;)                      //  Loop indefinitely
    if(p(++n)>1){             //   Increase `n` by 1 before every iteration with `++n`
                              //   And if it's a prime:
      int i=-k;for(;i<=k      //    Loop `i` from `-k` to `k` (inclusive)
        &p(n+i)<2|i==0;       //    As long as `n+i` is not a prime (skipping `n` itself)
        i+=2);                //    And iterate in steps of 2 instead of 1
      if(i>k)                 //    If we've reached the end of the loop:
        return n;}}           //     We've found our result, so return it

// Separated method to check if `n` is a prime
// `n` is a prime if it remained unchanged, and not when it became 0 or 1
int p(int n){for(int i=2;i<n;n=n%i++<1?0:n);return n;}

Python 2 , 105 104 bytes

^{-1 byte gracias a ovs}

n,k=input()
n+=1
while sum(all(x%i for i in range(2,x))^(x==n)for x in range(n-k*2,2*k-~n)):n+=1
print n

Pruébalo en línea!

Stax , 14 bytes

åΣ▀ë F▬&■º↔╔^∞

Ejecutar y depurarlo

Esta es la representación ascii correspondiente.

w^x:r{Hn+|p_!=m0#

w                   while; run the rest of the program until a falsy value remains
 ^                  increment candidate value.
  x:r               [-x, ..., -1, 0, 1, ... x] where x is the first input
     {        m     map using block, using k from -x to x
      Hn+           double and add to candidate value - this is "p+2k"
         |p         is it prime? produces 0 or 1
           _!       k is zero?
             =      two values are equal; always true for a passing candidate
               0#   any falses left after mapping? if so, continue running

JavaScript (Node.js) , 94 92 89 bytes

f=(n,k)=>(Q=y=>y<-k||(P=(a,b=2)=>a>b?a%b&&P(a,b+1):1)(n+2*y)^!!y&&Q(--y))(k,++n)?n:f(n,k)

Pruébalo en línea!

Misteriosamente, más campos de golf terminan por desbordarse. Solo esto funciona en el tamaño de 14000.

Finalmente, un campo de golf que no terminará desbordado en 14000.

Explicación

f=(n,k)=>            // Two inputs
 (Q=y=>              // Function checking whether all numbers in 
                     // [n-2*k, n+2*k] except n are all composite
  y<-k               // The counter runs from k to -k
                     // If none breaks the rule, return true
  ||(P=(a,b=2)=>     // Function checking primality
   a>b?              // Check if a>b
   a%b&&P(a,b+1)     // If a>b and a%b==0 return false, else proceed
   :1                // If a<=b return 1 (prime)
  )(n+2*y)^!!y       // If n+2*y is prime, then y must be 0
                     // If n+2*y is not prime, then y must be non-zero
                     // If none of the conditions are met, return false
  &&Q(--y)           // Else proceed to the next counter
 )
 (k,++n)?            // Add 1 to n first, then start the check
 n                   // If conditions are met, return n
 :f(n,k)             // Else proceed to the next n.

C (gcc) , 113 bytes

P(n,d,b){for(b=d=n>1;++d<n;)b=b&&n%d;n=b;}f(n,k,i,f){for(f=n;f;)for(f=i=!P(++n);i++<k;f|=P(n+i+i)|P(n-i-i));f=n;}

Pruébalo en línea!

Ruby + -rprime, 73 71 61 57 bytes

->n,k{n+=1;(-k..k).all?{|i|(i*2+n).prime?^(i!=0)}?n:redo}

Pruébalo en línea!

¡Se siente bien estar aprendiendo! Estoy usando las técnicas Integer#[]y redoque aprendí aquí en PPCG. perderse en las malas hierbas de técnicas divertidas ...

-1 byte: se usa en n%2lugar de n[0]para obtener el bit menos significativo. Gracias, Asone Tuhid !

-1 byte: utilice un operador ternario en lugar de una expresión booleana. Gracias, Asone Tuhid !

-10 bytes: use el operador XOR para evitar escribir .prime?dos veces ... Esta es la respuesta de Asone Tuhid tanto como la mía ahora :)

-4 bytes: no hay daño en comprobar incluso los valores de n. Asone Tuhid es sin parar.

Sin golf:

->n,k{
  n += 1;                   # Increment n
  (-k..k).all?{|i|          # In the set [n-2*k, n+2*k], is every number
    (i*2+n).prime? ^ (i!=0) #    EITHER prime XOR different from n itself?
  } ? n                     # If yes, return the current value of n
  : redo                    # Otherwise, restart the block
}

Pari / GP , 55 bytes

f(n,k)=until(isprime(n++)&&#primes([n-2*k,n+2*k])<2,);n

Pruébalo en línea!

Perl 6 , 63 bytes

{$^k;first {[grep *.is-prime,$_-2*$k..$_+2*$k]eqv[$_]},$^a^..*}

Pruébalo en línea!