Un nombre premier est faible si l'autre nombre premier le plus proche est plus petit que lui. S'il y a égalité, le nombre premier n'est pas faible.

Par exemple, 73 est un nombre premier faible parce que 71 est premier mais 75 est composite.

Tâche

Écrivez un code informatique qui, lorsqu'il reçoit un nombre premier supérieur à 2 en entrée, déterminera s'il s'agit d'un nombre premier faible. Il s'agit d'un problème de décision standard , vous devez donc générer deux valeurs uniques pour chacun des deux cas (par exemple, weaket not weak).

Il s'agit de code-golf , les règles standard pour le tag s'appliquent.

OEIS

Voici les 47 premiers nombres premiers faibles:

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

Voici l'OEIS pour les nombres premiers faibles (devrait revenir weak) OEIS A051635

Voici l'OEIS pour les nombres premiers équilibrés (devrait revenir not weak) OEIS A006562

Voici l'OEIS pour les nombres premiers forts (devrait revenir not weak) OEIS A051634

Gelée , 7 octets

Æn+Æp>Ḥ

Essayez-le en ligne!

Explication

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

En prime, le changement >de =ou des <chèques pour les nombres premiers équilibrés et solides, respectivement.

Mathematica, 24 octets

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

L' NextPrimeintégré peut être (ab?) Utilisé pour calculer le premier précédent en lui fournissant un argument négatif.

Gelée , 9 octets

ḤÆRạÞ⁸ḊḢ>

Renvoie 1pour faible et 0pour non faible ou équilibré (renvoie 1pour une entrée de 2)

Essayez-le en ligne!

Comment?

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

imprime un pour le premier faible et rien pour le premier non faible

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

Essayez-le en ligne!

Octave, 93 84 octets

Merci à @LuisMendo et @ rahnema1 pour avoir économisé des octets!

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

Essayez-le en ligne!

Maxima, 42 octets

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

Essayez-le en ligne!

MATL , 13 octets

qZq0)G_Yq+GE>

Cela sort 1si faible, 0sinon.

Essayez-le en ligne!

Explication

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 octets

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

∇f N déclare une fonction qui prend un argument.

(~R∊R∘.×R)/R←1↓⍳N×2donne une liste de tous les nombres premiers de 2 à deux fois l'argument. Je suppose que le premier prime est moins de deux fois l'original. Si ce n'est pas vrai, N*2donne N au carré et prend le même nombre d'octets (si tout va bien c'est assez grand pour dépasser le premier premier). (Voir l'explication de Wikipedia pour savoir comment fonctionne la recherche de prime)

X←(R←(...))⍳Naffecte cette liste au vecteur R(écrasant son contenu précédent), recherche l'index du nombre premier d'origine Ndans cette liste, puis affecte cet index à X.

|R[X-1]-Ncalcule la différence entre le premier précédent (car Rcontient les nombres premiers, le X-1e élément est le premier avant N) N, puis prend la valeur absolue (APL fonctionne de droite à gauche).

|R[X+1]-N fait de même, mais pour la prochaine prime.

(|R[X-1]-N)<|R[X+1]-Nimprime 1 si l'amorce précédente est plus proche de l'original que l'amorce suivante et 0 sinon. Des parenthèses sont nécessaires pour la priorité.

∇ termine la fonction.

Gelée , 9 octets

Æp;;ÆnI</

Essayez-le en ligne!

Pyth, 15 octets

>-fP_ThQfPT_tQy

Essayez-le ici.

Utilise l'algorithme de Pietu1998.

Perl 6 , 41 octets

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

Essayez-le en ligne!

$_est l'argument de la fonction. La fonction de mappage -> \n { $_ + n, * + n ... &is-prime }prend un nombre net renvoie une séquence de nombres $_ + n, $_ + 2*n, ...qui se termine lorsqu'elle atteint un nombre premier. Le mappage de cette fonction sur les deux nombres 1et -1produit une séquence de deux séquences; le premier commence par $_ + 1et se termine par le premier nombre premier supérieur à $_, et le second commence par $_ - 1et se termine par le premier nombre premier inférieur à $_. [>]réduit cette liste à deux éléments avec l'opérateur supérieur à, retournant vrai si la première séquence est plus grande (c'est-à-dire plus longue) que la seconde.

Python 2.7 - 120 octets

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)

Puisque python n'a pas de fonction principale intégrée, nous pouvons utiliser le théorème de Wilson pour obtenir un joli vérificateur premier court. Le théorème de Wilson déclare qu'un nombre est premier si et seulement si (n-1)! est congru à -1 mod (n). Par conséquent, la fonction i renverra 1 si le nombre est premier et 0 si ce n'est pas le cas. Ensuite, la fonction f déterminera si le premier nombre premier de ce nombre se produit en premier lors de l'incrémentation vers le bas plutôt que vers le haut. Si aucun des nombres incrémentés n'est premier, il est simplement rappelé de manière récursive.

Quelques exemples d'E / S

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

Python 2 , 122 108 103 103 94 92 octets

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

Essayez-le en ligne!

Utilise l'idée de Pietu ... puis a sauvé 28 octets en jouant au golf des itérateurs de liste principale plus courts; puis 2 de plus en remplaçant -3*n>0par >3*n(d'oh!)

Regex (la plupart des saveurs), 47 octets

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

Essayez-le en ligne!

Prend entrée en unaire. Génère une correspondance pour les nombres premiers faibles, aucune correspondance pour les nombres premiers non faibles. Fonctionne en ECMAScript, Perl, PCRE, Python, Ruby.

Explication:

Soit N l'entrée, A le premier le plus proche <N et B le premier le plus proche> N. La principale difficulté d'une approche regex de ce défi est que nous ne pouvons pas représenter des nombres supérieurs à l'entrée, comme B. Au lieu de cela, nous trouver le plus petit b tel que 2b + 1 est premier et 2b + 1> N, ce qui garantit 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)
)

Ensuite, notez que nous n'avons pas vraiment besoin de trouver A. Tant que tout premier <N est plus proche de N que B, N est un premier faible.

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

Octave, 53 octets

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

Essayez-le en ligne!

JavaScript ES6, 162 154 octets

8 octets de sauvegarde sur la base de l' astuce de Jörg Hülsermann "ne rien imprimer dans un seul cas". Pas besoin ?"Y":"N"aprè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 octets

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

Essayez-le en ligne!

Utilise l'algorithme de Pietu1998.

Python 3 , 149 octets

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

Essayez-le en ligne!

J'utilise une fonction de génération principale (ligne supérieure) tirée de cette ancienne réponse d'échange de pile.

JavaScript, 98 octets

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>

Moins 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
}

Notez que le code de test ne vérifie pas que l'entrée "prime" est en fait un nombre premier.

braingasme , 23 22 octets

Imprime 1pour des nombres premiers faibles et 0pour non faibles.

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

Procédure pas à pas:

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

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 octets

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

Essayez-le en ligne!

Utilise le théorème de Wilson pour le test de primalité.