Un numero primo è debole se l'altro primo più vicino è più piccolo di esso. Se c'è un pareggio il primo non è debole.

Ad esempio 73 è un numero primo debole perché 71 è primo, ma 75 è composito.

Compito

Scrivi un codice per computer che quando viene dato un numero primo maggiore di 2 come input determinerà se si tratta di un numero primo debole. Questo è un problema decisionale standard , quindi dovresti generare due valori univoci per ciascuno dei due casi (ad es. weakE not weak).

Questo è code-golf, quindi si applicano le regole standard per il tag.

OEIS

Ecco i primi 47 numeri primi deboli:

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

Ecco l'OEIS per i numeri primi deboli (dovrebbe tornare weak) OEIS A051635

Ecco l'OEIS per numeri primi bilanciati (dovrebbe restituire not weak) OEIS A006562

Ecco l'OEIS per i numeri primi forti (dovrebbe tornare not weak) OEIS A051634

Gelatina , 7 byte

Æn+Æp>Ḥ

Provalo online!

Spiegazione

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

Come bonus, che cambia >a =o <assegni per i numeri primi equilibrati e forti, rispettivamente.

Mathematica, 24 byte

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

Il NextPrimebuilt-in può essere (ab?) Utilizzato per calcolare il primo precedente fornendo un argomento negativo.

Gelatina , 9 byte

ḤÆRạÞ⁸ḊḢ>

Restituisce 1per debole e 0per non debole o bilanciato (ritorna 1per un input di 2)

Provalo online!

Come?

ḤÆ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 byte

stampa uno per il primo debole e niente per il primo non debole

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

Provalo online!

Ottava, 93 84 byte

Grazie a @LuisMendo e @ rahnema1 per aver salvato byte!

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

Provalo online!

Maxima, 42 byte

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

Provalo online!

MATL , 13 byte

qZq0)G_Yq+GE>

Questo emette 1se debole, 0altrimenti.

Provalo online!

Spiegazione

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 byte

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

∇f N dichiara una funzione che accetta un argomento.

(~R∊R∘.×R)/R←1↓⍳N×2fornisce un elenco di tutti i numeri primi da 2 a due volte l'argomento. Suppongo che il prossimo numero primo sia meno del doppio dell'originale. Se questo non è vero, N*2dà N al quadrato e prende lo stesso numero di byte (si spera che sia abbastanza grande da superare il primo primo). (Vedi la spiegazione di Wikipedia su come funziona la ricerca dei primi)

X←(R←(...))⍳Nassegna tale elenco al vettore R(sovrascrivendo il contenuto precedente), trova l'indice del numero primo originale Nin quell'elenco e quindi assegna tale indice a X.

|R[X-1]-Ncalcola la differenza tra il primo precedente (poiché Rcontiene i numeri primi, l' X-1elemento th è il primo in precedenza N) Ne quindi assume il valore assoluto (APL opera da destra a sinistra).

|R[X+1]-N fa lo stesso, ma per il prossimo primo.

(|R[X-1]-N)<|R[X+1]-Nstampa 1 se il primo precedente è più vicino all'originale rispetto al primo successivo e 0 altrimenti. Le parentesi sono necessarie per la precedenza.

∇ termina la funzione.

Gelatina , 9 byte

Æp;;ÆnI</

Provalo online!

Pyth, 15 byte

>-fP_ThQfPT_tQy

Provalo qui.

Utilizza l'algoritmo di Pietu1998.

Perl 6 , 41 byte

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

Provalo online!

$_è l'argomento della funzione. La funzione di mappatura -> \n { $_ + n, * + n ... &is-prime }accetta un numero ne restituisce una sequenza di numeri $_ + n, $_ + 2*n, ...che termina quando raggiunge un numero primo. Mappando questa funzione sui due numeri 1e -1produce una sequenza di due sequenze; il primo inizia con $_ + 1e termina con il primo numero primo maggiore di $_, e il secondo inizia con $_ - 1e termina con il primo numero primo minore di $_. [>]riduce questo elenco di due elementi con l'operatore maggiore di, restituendo vero se la prima sequenza è maggiore (ovvero più lunga) della seconda.

Python 2.7 - 120 byte

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)

Dal momento che python non ha una funzione primaria integrata, possiamo usare il teorema di Wilson per ottenere un buon controllo di prime prime. Il teorema di Wilson afferma che un numero è primo se e solo se (n-1)! è congruente a -1 mod (n). Quindi la funzione restituirò 1 se il numero è primo e 0 se non lo è. In seguito, la funzione f determinerà se il primo primo di quel numero si verifica per primo quando viene incrementato verso il basso anziché incrementato verso l'alto. Se nessuno dei numeri incrementati è primo, viene richiamato in modo ricorsivo.

Alcuni esempi di I / O

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

Python 2 , 122 108 103 94 92 byte

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

Provalo online!

Usa l'idea di Pietu ... e quindi salva 28 byte giocando a golf su iteratori di elenco di prime più brevi; poi altri 2 sostituendoli -3*n>0con >3*n(d'oh!)

Regex (la maggior parte dei gusti), 47 byte

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

Provalo online!

Riceve input in unario. Emette una corrispondenza per numeri primi deboli, nessuna corrispondenza per numeri primi non deboli. Funziona in ECMAScript, Perl, PCRE, Python, Ruby.

Spiegazione:

Sia N l'input, A il primo più vicino <N e B il primo più vicino> N. La principale difficoltà di un approccio regex a questa sfida è che non possiamo rappresentare numeri maggiori dell'input, come B. Invece, noi trova la b più piccola in modo che 2b + 1 sia primo e 2b + 1> N, che garantisce 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)
)

Quindi, nota che in realtà non abbiamo bisogno di trovare A. Finché un numero primo <N è più vicino a N di B, N è un numero primo debole.

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

Ottava, 53 byte

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

Provalo online!

JavaScript ES6, 162 154 byte

Risparmio di 8 byte basato sul trucco di Jörg Hülsermann "non stampare nulla in un caso". Non c'è bisogno di ?"Y":"N"dopoone<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 byte

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

Provalo online!

Utilizza l'algoritmo di Pietu1998.

Python 3 , 149 byte

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

Provalo online!

Sto usando una funzione di generazione primaria (riga superiore) tratta da questa vecchia risposta di scambio di stack.

JavaScript, 98 byte

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>

Meno golfato

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
}

Si noti che il codice di test non verifica che l'ingresso "prime" sia in realtà un numero primo.

Braingasm , 23 22 byte

Stampa 1per numeri primi deboli e 0non deboli.

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

Procedura dettagliata:

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

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 byte

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

Provalo online!

Utilizza il teorema di Wilson per il test di primalità.