Um primo é fraco se o outro primo mais próximo for menor que ele. Se houver um empate, o prime não é fraco.

Por exemplo, 73 é um primo fraco porque 71 é primo, mas 75 é composto.

Tarefa

Escreva um código de computador que, quando fornecido um primo maior que 2, como entrada, determinará se é um primo fraco. Esse é um problema de decisão padrão , portanto, você deve gerar dois valores exclusivos para cada um dos dois casos (por exemplo, weake not weak).

Isso é código-golfe, então as regras padrão para a tag se aplicam.

OEIS

Aqui estão os primeiros 47 números primos fracos:

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

Aqui está o OEIS para números primos fracos (deve retornar weak) OEIS A051635

Aqui está o OEIS para números primos equilibrados (deve retornar not weak) OEIS A006562

Aqui está o OEIS para números primos fortes (deve retornar not weak) OEIS A051634

Geléia , 7 bytes

Æn+Æp>Ḥ

Experimente online!

Explicação

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

Como bônus, mudar >para =ou procurar <por números primos equilibrados e fortes, respectivamente.

Mathematica, 24 bytes

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

O NextPrimebuilt-in pode ser (ab?) Usado para calcular o primo anterior, alimentando-o com um argumento negativo.

Geléia , 9 bytes

ḤÆRạÞ⁸ḊḢ>

Retorna 1para fraco e 0para não fraco ou equilibrado (retorna 1para uma entrada de 2)

Experimente online!

Quão?

ḤÆ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 um para prime fraco e nada para prime não fraco

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

Experimente online!

Oitava, 93 84 bytes

Obrigado a @LuisMendo e @ rahnema1 por salvar 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;

Experimente online!

Máximos, 42 bytes

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

Experimente online!

MATL , 13 bytes

qZq0)G_Yq+GE>

Isso produz, 1se fraco, 0caso contrário.

Experimente online!

Explicação

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 uma função que aceita um argumento.

(~R∊R∘.×R)/R←1↓⍳N×2fornece uma lista de todos os números primos de 2 a duas vezes o argumento. Estou assumindo que o próximo primo é menos que o dobro do original. Se isso não for verdade, N*2fornece N ao quadrado e leva o mesmo número de bytes (espero que seja grande o suficiente para exceder o próximo primo). (Veja a explicação da Wikipedia sobre como funciona a descoberta principal)

X←(R←(...))⍳Natribui essa lista ao vetor R(substituindo seu conteúdo anterior), localiza o índice do primo original Nnessa lista e atribui esse índice aX .

|R[X-1]-Ncalcula a diferença entre o primo anterior (porque Rcontém os primos, o X-1elemento th é o primo anterior N) eN e, em seguida, assume o valor absoluto (o APL opera da direita para a esquerda).

|R[X+1]-N faz o mesmo, mas para o próximo prime.

(|R[X-1]-N)<|R[X+1]-Nimprime 1 se o prime anterior estiver mais próximo do original que o próximo prime e 0 em caso contrário. Parênteses são necessários para precedência.

∇ finaliza a função.

Geléia , 9 bytes

Æp;;ÆnI</

Experimente online!

Pitão, 15 bytes

>-fP_ThQfPT_tQy

Experimente aqui.

Usa o algoritmo de Pietu1998.

Perl 6 , 41 bytes

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

Experimente online!

$_é o argumento para a função A função de mapeamento -> \n { $_ + n, * + n ... &is-prime }pega um número ne retorna uma sequência de números$_ + n, $_ + 2*n, ... que termina quando atinge um número primo. Mapear esta função sobre os dois números 1e -1produz uma sequência de duas seqüências; o primeiro começa com $_ + 1e termina com o primeiro número primo maior que $_e o segundo começa com $_ - 1e termina com o primeiro número primo menor que $_. [>]reduz essa lista de dois elementos com o operador maior que, retornando true se a primeira sequência for maior (ou seja, mais longa) que a 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)

Como o python não possui uma função embutida é primordial, podemos usar o teorema de Wilson para obter um bom verificador primário curto. O teorema de Wilson afirma que um número é primo se e somente se (n-1)! é congruente a -1 mod (n). Portanto, a função retornará 1 se o número for primo e 0 se não for. Depois disso, a função f determinará se o próximo primo desse número ocorrerá primeiro quando incrementado para baixo, em vez de incrementado para cima. Se nenhum dos números incrementados for primo, é apenas chamado recursivamente novamente.

Alguns exemplos 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

Experimente online!

Usa a idéia de Pietu ... e depois salvou 28 bytes ao jogar iteradores mais curtos da lista principal; mais 2 substituindo -3*n>0por >3*n(d'oh!)

Regex (a maioria dos sabores), 47 bytes

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

Experimente online!

Recebe entrada em unário. Produz uma correspondência para números primos fracos, nenhuma correspondência para números primos não fracos. Trabalha em ECMAScript, Perl, PCRE, Python, Ruby.

Explicação:

Seja N a entrada, A o primo mais próximo <N e B o primo mais próximo> N. A principal dificuldade de uma abordagem de expressão regular para esse desafio é que não podemos representar números maiores que a entrada, como B. Em vez disso, Encontre o menor b de modo que 2b + 1 seja primo e 2b + 1> N, o que garante 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)
)

Então, observe que não precisamos encontrar A. Contanto que qualquer primo <N esteja mais próximo de N que B, N é um primo fraco.

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

Oitava, 53 bytes

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

Experimente online!

JavaScript ES6, 162 154 bytes

Economize 8 bytes com base no truque de Jörg Hülsermann "imprima nada em um caso". Não é necessário ?"Y":"N"depoisone<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#]+¹·›

Experimente online!

Usa o 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))

Experimente online!

Eu estou usando uma função de geração principal (linha superior) tirada desta antiga resposta de troca de pilhas.

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 Golphed

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
}

Observe que o código de teste não verifica se a entrada "prime" é realmente uma prime.

braingasm , 23 22 bytes

Imprime 1para números primos fracos e 0para não fracos.

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

Passo a passo:

;                       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

Experimente online!

Usa o teorema de Wilson para o teste de primalidade.