Un primo es débil si el otro primo más cercano es más pequeño que él. Si hay un empate, el prime no es débil.

Por ejemplo, 73 es un primo débil porque 71 es primo pero 75 es compuesto.

Tarea

Escriba un código de computadora que cuando se le dé un primo mayor que 2 como entrada determinará si es un primo débil. Este es un problema de decisión estándar , por lo que debe generar dos valores únicos para cada uno de los dos casos (por ejemplo, weaky not weak).

Este es el código de golf, por lo que se aplican las reglas estándar para la etiqueta.

OEIS

Aquí están los primeros 47 primos débiles:

3, 7, 13, 19, 23, 31, 43, 47, 61, 73, 83, 89, 103, 109, 113, 131, 139, 151, 167, 181, 193, 199, 229, 233, 241, 271, 283, 293, 313, 317, 337, 349, 353, 359, 383, 389, 401, 409, 421, 433, 443, 449, 463, 467, 491, 503, 509, 523, 547, 571, 577, 601, 619, 643, 647

Aquí está el OEIS para números primos débiles (debería regresar weak) OEIS A051635

Aquí está el OEIS para primos balanceados (debería regresar not weak) OEIS A006562

Aquí está el OEIS para números primos fuertes (debería regresar not weak) OEIS A051634

Jalea , 7 bytes

Æn+Æp>Ḥ

Pruébalo en línea!

Explicación

           See if
Æn         the next prime
  +Æp      plus the previous prime
     >Ḥ    is greater than 2n

Como beneficio adicional, el cambio >a =o <cheques por números primos equilibrados y fuertes, respectivamente.

Mathematica, 24 bytes

n=NextPrime;2#+n@-#<n@#&

El NextPrimeincorporado puede ser (ab?) Usado para calcular el primo anterior al alimentarlo con un argumento negativo.

Jalea , 9 bytes

ḤÆRạÞ⁸ḊḢ>

Devuelve 1para débil y 0para no débil o equilibrado (devuelve 1para una entrada de 2)

Pruébalo en línea!

¿Cómo?

ḤÆRạÞ⁸ḊḢ> - Link: prime number > 2, p
Ḥ         - double -> 2*p
 ÆR       - yield primes between 2 and 2*p inclusive
     ⁸    - chain's left argument, p
    Þ     - sort by:
   ạ      -   absolute difference (i.e. distance from p)
      Ḋ   - dequeue (removes p from the list, since it has distance zero)
       Ḣ  - head (gives us the nearest, if two the smallest of the two)
        > - greater than p?

PHP , 69 bytes

imprime uno para cebado débil y nada para cebado no débil

for(;!$t;$t=$d<2)for($n=$d=$argn+$i=-$i+$w^=1;$n%--$d;);echo$n<$argn;

Pruébalo en línea!

Octava, 93 84 bytes

¡Gracias a @LuisMendo y @ rahnema1 por guardar bytes!

function r=f(x);i=j=x;do--i;until(i<1|isprime(i));do++j;until(isprime(j));r=x-i<j-x;

Pruébalo en línea!

Máximo, 42 bytes

f(n):=is(n-prev_prime(n)<next_prime(n)-n);

Pruébalo en línea!

MATL , 13 bytes

qZq0)G_Yq+GE>

Esto sale 1si es débil, de lo 0contrario.

Pruébalo en línea!

Explicación

q      % Implicit input, Subtract 1
Zq     % Vector of primes up to that
0)     % Get last one
G      % Push input again
_Yq    % Next prime
+      % Add
G      % Push input
E      % Multiply by 2
>      % Greater than? Implicit display

GNU APL 1.2, 78 bytes

∇f N
X←(R←(~R∊R∘.×R)/R←1↓⍳N×2)⍳N
(|R[X-1]-N)<|R[X+1]-N
∇

∇f N declara una función que toma un argumento.

(~R∊R∘.×R)/R←1↓⍳N×2da una lista de todos los números primos del 2 al doble del argumento. Supongo que el próximo primo es menos del doble del original. Si esto no es cierto, N*2da N al cuadrado y toma el mismo número de bytes (es de esperar que sea lo suficientemente grande como para exceder el próximo número primo). (Consulte la explicación de Wikipedia sobre cómo funciona el hallazgo principal)

X←(R←(...))⍳Nasigna esa lista al vector R(sobrescribiendo su contenido anterior), encuentra el índice del primo original Nen esa lista y luego le asigna ese índice X.

|R[X-1]-Ncalcula la diferencia entre el primo anterior (porque Rcontiene los primos, el X-1elemento th es el primo antes N) Ny luego toma el valor absoluto (APL funciona de derecha a izquierda).

|R[X+1]-N hace lo mismo, pero para el próximo prime.

(|R[X-1]-N)<|R[X+1]-Nimprime 1 si el primo anterior está más cerca del original que el próximo y 0 en caso contrario Los paréntesis son necesarios para la precedencia.

∇ termina la función

Jalea , 9 bytes

Æp;;ÆnI</

Pruébalo en línea!

Pyth, 15 bytes

>-fP_ThQfPT_tQy

Pruébalo aquí

Utiliza el algoritmo de Pietu1998.

Perl 6 , 41 bytes

{[>] map ->\n{$_+n,*+n...&is-prime},1,-1}

Pruébalo en línea!

$_es el argumento de la función La función de mapeo -> \n { $_ + n, * + n ... &is-prime }toma un número ny devuelve una secuencia de números $_ + n, $_ + 2*n, ...que termina cuando alcanza un número primo. Mapeando esta función sobre los dos números 1y -1produce una secuencia de dos secuencias; el primero comienza con $_ + 1y termina con el primer número primo mayor que $_, y el segundo comienza con $_ - 1y termina con el primer número primo menor que $_. [>]reduce esta lista de dos elementos con el operador mayor que, devolviendo verdadero si la primera secuencia es mayor (es decir, más larga) que la segunda.

Python 2.7 - 120 bytes

from math import*
i=lambda x:factorial(x-1)%x==x-1
def f(n,c):return 1 if i(n-c)>i(n+c) else 0 if i(n+c)>0 else f(n,c+1)

Dado que Python no tiene una función primordial incorporada, podemos usar el teorema de Wilson para obtener un buen corrector primo corto. ¡El teorema de Wilson establece que un número es primo si y solo si (n-1)! es congruente con -1 mod (n). Por lo tanto, la función i devolverá 1 si el número es primo y 0 si no lo es. Después de eso, la función f determinará si el primer primo de ese número ocurre primero cuando se incrementa hacia abajo en lugar de hacia arriba. Si ninguno de los números incrementados es primo, solo se llama de forma recursiva nuevamente.

Algunos ejemplos de E / S

f(3,1)
1
f(15,1)
0

Python 2 , 122 108 103 94 92 bytes

def a(n):
 r=[2];x=2
 while r[-1]<=n:x+=1;r+=[x]*all(x%i for i in r)
 return sum(r[-3:])>3*n

Pruébalo en línea!

Usa la idea de Pietu ... y luego ahorró 28 bytes jugando golf a los iteradores de la lista principal más cortos; luego 2 más reemplazando -3*n>0con >3*n(¡oh!)

Regex (la mayoría de los sabores), 47 bytes

^(?=(x*)(?!(x+)(\2\2x)+$)\1)x+(?!(xx+)\4+$)\1\1

Pruébalo en línea!

Toma entrada en unario. Emite una coincidencia para primos débiles, no coincide para primos no débiles. Funciona en ECMAScript, Perl, PCRE, Python, Ruby.

Explicación:

Sea N la entrada, A el primo más cercano <N, y B el primo más cercano> N. La principal dificultad de un enfoque de expresiones regulares para este desafío es que no podemos representar números mayores que la entrada, como B. En cambio, nosotros encuentre el b más pequeño de modo que 2b + 1 sea primo y 2b + 1> N, lo que garantiza que 2b + 1 = B.

(?=
  (x*)              # \1 = N - b, tail = b
  (?!(x+)(\2\2x)+$) # Assert 2b + 1 is prime
  \1                # Assert b ≥ \1 (and thus 2b + 1 > N)
)

Luego, tenga en cuenta que en realidad no necesitamos encontrar A. Siempre que cualquier primo <N esté más cerca de N que B, N es un primo débil.

x+                  # tail iterates over integers < N
(?!(xx+)\4+$)       # assert tail is prime
\1\1                # assert tail ≥ 2 * \1 (and thus tail + B > 2N)

Octava, 53 bytes

@(n)diff(list_primes(h=nnz(primes(n))+1)(h-2:h),2)>0

Pruébalo en línea!

JavaScript ES6, 162 154 bytes

Ahorro de 8 bytes basado en el truco de Jörg Hülsermann "no imprimir nada en un caso". No es necesario ?"Y":"N"despuésone<two

var isWeak=

a=>{p=[2];i=0;f=d=>{j=p[i];l:while(j++){for(x=0;p[x]*p[x]<=j;x++){if(j%p[x]==0){continue l}}return p[++i]=j}};while(p[i]<a+1){f()};return a*2<p[i]+p[i-2]}

[43,//true
53,//false
7901,//false
7907,//true
1299853,//true
1299869//false
].forEach(n=>{console.log(n,isWeak(n))})

05AB1E , 17 bytes

[<Dp#]¹[>Dp#]+¹·›

Pruébalo en línea!

Utiliza el algoritmo de Pietu1998.

Python 3 , 149 bytes

f=lambda n,k=1,P=1:n*[0]and P%k*[k]+f(n-P%k,k+1,P*k*k)
def a(n):p=f(n);return p.index(n)in filter(lambda i:p[i]-p[i-1]<p[i+1]-p[i],range(1,len(p)-1))

Pruébalo en línea!

Estoy usando una función de generación principal (línea superior) tomada de esta antigua respuesta de intercambio de pila.

JavaScript, 98 bytes

let test = _=>(o.innerHTML=f(+prime.value))
let f= 

n=>{P=n=>{for(i=n,p=1;--i>1;)p=p&&n%i};a=b=n;for(p=0;!p;P(--a));for(p=0;!p;P(++b));return n-a<b-n}

Enter Prime: <input id="prime">
<button type="button" onclick="test()">test if weak</button>
<pre id="o"></pre>

Menos golpeado

n=>{
   P=  // is a Prime greater than 1, result in p
       n=>{
           for(i=n,p=1;--i>1;)
               p=p&&n%i
       };

   a=b=n; // initialize lower and upper primes to n
   for(p=0;!p;P(--a)); // find lower,
   for(p=0;!p;P(++b)); // find upper,
   return n-a<b-n // is weak result
}

Tenga en cuenta que el código de prueba no verifica que la entrada "primo" sea realmente un primo.

braingasm , 23 22 bytes

Imprime 1para primos débiles y 0para no débiles.

;>0$+L[->+>2[>q[#:Q]]]

Tutorial:

;                       Read a number to cell 0
 >0$+                   Go to cell 1 and copy the value of cell 0
     L                  Make the tape wrap around after cell 1
      [              ]  Loop:
       ->+>               Decrease cell 1 and increase cell 0
           2[       ]     Twice do:
             >              Go to the other cell
              q[   ]        If it's prime:
                #:Q         Print the current cell number and quit

Julia 0.6, 64 bytes

g(x,i)=0∉x%(2:x-1)?1:1+g(x+i,i);x->g(x,1)&(g(x-1,-1)<g(x+1,1))

Python 2 , 81 bytes

n=input()
a=b=c=i=2;p=1
while b<n:
 p*=i;i+=1
 if p*p%i:a,b,c=b,c,i
print a+c>2*b

Pruébalo en línea!

Utiliza el teorema de Wilson para la prueba de primalidad.