Un nombre est un nombre premier de Chen s'il remplit deux conditions:

• C'est le premier lui-même
• Lui-même plus deux est un nombre premier ou semi-premier.

Un nombre premier est un nombre où il a exactement deux diviseurs et ces diviseurs se composent de lui-même et d'un.

Un semi-premier est un nombre qui est le produit de deux nombres premiers. (Notez que 12 = 2 * 2 * 3 n'est pas semi-premier, mais 25 = 5 * 5 l'est).

Votre tâche consiste à déterminer si un nombre est un nombre premier de Chen. Vous devez afficher toute valeur vraie pour oui et toute valeur fausse pour non.

L'entrée sera un entier supérieur ou égal à un. Il peut également être considéré comme une chaîne, un tableau de caractères ou un tableau ou des chiffres.

Exemples:

101 -> truthy
223 -> falsy
233 -> truthy
1 -> falsy

Il s'agit d'OEIS A109611 .

Ceci est en partie inspiré par Am I a Sophie Germain prime? qui, malheureusement, a été fermé en double, donc je poste un défi quelque peu similaire qui n'est pas un double.

Brachylog , 7 octets

ṗ+₂ḋl≤2

Essayez-le en ligne!

Explication

ṗ         Input is prime       
   ḋ      The prime factorization of…
 +₂       … Input + 2…
    l≤2   … has 2 or less elements

05AB1E , 8 octets

p¹ÌÒg3‹*

Essayez-le en ligne!

Explication

p¹ÌÒg3‹*   Argument n
p          Push isPrime(n)
 ¹ÌÒ       Push list of prime factors of (n+2)
    g3‹    Length of list is lower than 3
       *   Multiplication of boolean values, 0 if either is 0 (false)

ArnoldC , 1339 octets

LISTEN TO ME VERY CAREFULLY q
I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE p
GIVE THESE PEOPLE AIR
HEY CHRISTMAS TREE c
YOU SET US UP 0
HEY CHRISTMAS TREE d
YOU SET US UP 0
HEY CHRISTMAS TREE l
YOU SET US UP p
STICK AROUND l
GET TO THE CHOPPER d
HERE IS MY INVITATION p
I LET HIM GO l
ENOUGH TALK
BECAUSE I'M GOING TO SAY PLEASE d
BULLSHIT
GET TO THE CHOPPER c
HERE IS MY INVITATION c
GET UP 1
ENOUGH TALK
YOU HAVE NO RESPECT FOR LOGIC
GET TO THE CHOPPER l
HERE IS MY INVITATION l
GET DOWN 1
ENOUGH TALK
CHILL
I'LL BE BACK c
HASTA LA VISTA, BABY
IT'S SHOWTIME
HEY CHRISTMAS TREE p
YOU SET US UP 0
GET YOUR ASS TO MARS p
DO IT NOW
I WANT TO ASK YOU A BUNCH OF QUESTIONS AND I WANT TO HAVE THEM ANSWERED IMMEDIATELY
HEY CHRISTMAS TREE n
YOU SET US UP 0
GET YOUR ASS TO MARS n
DO IT NOW q p
HEY CHRISTMAS TREE g
YOU SET US UP 42
GET TO THE CHOPPER g
HERE IS MY INVITATION n
YOU ARE NOT YOU YOU ARE ME 2
ENOUGH TALK
BECAUSE I'M GOING TO SAY PLEASE g
GET TO THE CHOPPER p
HERE IS MY INVITATION p
GET UP 2
ENOUGH TALK
GET YOUR ASS TO MARS n
DO IT NOW q p
GET TO THE CHOPPER g
HERE IS MY INVITATION 5
LET OFF SOME STEAM BENNET n
ENOUGH TALK
BECAUSE I'M GOING TO SAY PLEASE g
TALK TO THE HAND "t"
BULLSHIT
TALK TO THE HAND "f"
YOU HAVE NO RESPECT FOR LOGIC
BULLSHIT
TALK TO THE HAND "f"
YOU HAVE NO RESPECT FOR LOGIC
YOU HAVE BEEN TERMINATED

Essayez-le en ligne!

(Ceci est mon premier article sur codegolf.SE, faites-le moi savoir s'il est mal formaté. Je me rends compte que ce nombre d'octets n'est pas compétitif, c'est juste pour le plaisir.)

Gelée , 10 octets

+2ÆfL<3aÆP

Essayez-le en ligne!

Pyth, 10 octets

&P_Q>3lP+2

Essayez-le en ligne!

Comment?

&P_Q>3lP+2  # input: Q
        +2  # Q + 2
       P    # prime factors
    >3l     # length lower than 3?
 P_Q        # Q is prime?
&           # and both results

Python avec sympy ,  69  56 octets

-13 octets grâce à alephalpha (en passant à sympy 1.1 et en utilisant primeomega(n+2)pour remplacer sum(factorint(n+2).values()))

... succédant à la soumission supprimée de Gryphon.

from sympy import*
lambda n:primeomega(n+2)<3*isprime(n)

Une fonction sans nom retournant Truepour les nombres premiers de Chen et Falseautrement.

Compte les facteurs de n+2en additionnant les multiplicités de son facteur premier.

Notez que 3est multiplié par isprime(n)avant que la <comparaison ne soit faite, donc pour non-prime nle code teste si n+2a moins de 0facteurs (toujours en rendement False), tandis que pour prime nil vérifie si n+2est premier ou semi-premier.

Pari / GP , 29 octets

L' 3*isprime(n)astuce est dérobée à la réponse de Jonathan Allan .

n->bigomega(n+2)<3*isprime(n)

Essayez-le en ligne!

Java 8, 85 84 83 octets

n->{int a=n+2,b=0,c=0,i=1;for(;i++<n;b+=n%i<1?1:0)c+=a%i<1?1:0;return n>1&b<2&c<3;}

-1 octets grâce à @ OlivierGrégoire en utilisant une approche itérative au lieu de récursive.

Explication:

Essayez-le ici.

n->{            // Method with integer parameter and boolean return-type
  int a=n+2,    //  Start `a` at the input + 2
      b=0,c=0,  //  Start `b` and `c` at 0
      i=1;      //  Start `i` at 1
  for(;i++<n;   //  Loop from 1 to `n` (and raise `i` immediately by 1)
    b+=n%i<1?   //   If the input is divisible by `i`
        1       //    Raise `b` by 1
       :        //   Else:
        0)      //    Leave `b` as is
    c+=a%i<1?   //   If the input + 2 is divisible by `i`:
        1       //    Raise `c` by 1
       :        //   Else:
        0;      //    Leave `c` as is
                //  End of loop (implicit / single-line body)
  return n>1    //  Return if the input is larger than 1
         &b<2   //   And `b` is now smaller than 2
         &c<3;  //   And `c` is now smaller than 3
}               // End of method

Mathematica, 28 octets

PrimeQ@#&&PrimeOmega[#+2]<3&

JavaScript (ES6), 63 61 octets

g=(e,i=e)=>i--<3?1:e%i?g(e,i):g(i)+1
f=e=>e>1&g(e)<2&g(e+2)<3

Test cases:<br><textarea id=i rows=6 oninput="go()">101&#10;223&#10;233&#10;1</textarea><br><pre id=q></pre><script>window.onload=function go(){document.getElementById('q').innerHTML=document.getElementById('i').value.split('\n').map(e=>e+' -> '+f(+e)).join('\n')}</script>

Définit une fonction fqui prend ncomme argument et renvoie le résultat. Im très heureux de la façon dont gs'est avéré; il compte le nombre de facteurs premiers dans un nombre.

Sauvegarde de 2 octets grâce à l' &astuce de Kevin Cruijssen .

Non golfé

Ω = (n,          // Ω(n) = number of n's prime factors, n > 1.
    i = n) =>    // Start iterating from i = n - 1. Since we'll immediately
                 // decrement i, n is used here.
    --i          // Immediately decrement i.

    < 2          // If i = 0 or i = 1, n is a prime at this point.
    ? 1 :        // Therefore Ω(n) = 1.

    n % i != 0 ? // If n is not divisible by i,
    Ω(n, i)      // try again with i := i - 1 (immediately decremented, so use i).

    : Ω(i) + 1   // n is divisible by i. Since we're counting down from n - 1
                 // and i is the first such number, i is n's largest non-trivial
                 // divisor, and thus n/i is a prime.
                 // Therefore Ω(n) = Ω(i) + Ω(n/i) = Ω(i) + 1.

is_chen = n =>     // An integer n ≥ 1 is a Chen prime if and only if:
    n > 1          // n > 1,
    & Ω(n) < 2     // Ω(n) = 1 < 2, i.e. n is a prime, and
    & Ω(n + 2) < 3 // Ω(n + 2) < 3, i.e. n + 2 is a prime or a semiprime.

Japt , 22 20 19 13 12 octets

U°j ©2¨°Uk l

• 6 octets enregistrés grâce à la suggestion d'Obarakon d'une méthode différente.

Essaye-le

PHP, 64 octets

for($i=$n=$argn+2;--$i;$argn%$i?:$q++)$n%$i?:++$p;echo$p<4^--$q;

imprime 0pour véridique, d'autres entiers pour faux. Exécuter en tant que pipe avec -nRou l' essayer en ligne .

panne

for($i=$n=$argn+2;--$i; # loop $i from N+1 to 1
    $argn%$i?:$q++)         # if $i divides N, increment $q
    $n%$i?:++$p;            # if $i divides N+2, increment $p
echo$p<4                # $p is 1 for a prime, 3 for a semiprime
    ^--$q;              # $q is 2 for prime; so this is 1^1 (==0) for a Chen Prime

valeur de fausse cohérence, 65 octets:

for($i=$n=2+$k=$argn;--$i;$k%$i?:$q++)$n%$i?:++$p;echo$p<4&$q==2;

imprime 1pour la vérité et 0pour la fausseté.

Python 3 avec SymPy, 73 71 octets

lambda n:(sum(factorint(n+2).values())<3)&isprime(n)
from sympy import*

Essayez-le en ligne!

Il s'agit d'une version plus élaborée d'une réponse publiée ici plus tôt, mais elle semble avoir été supprimée.

Merci à @JonathanAllan d'avoir économisé 2 octets!

PHP , 87 octets

for($b=($a=$argn)+$i=2;2<$a+$b;)$a%$i?$b%$i?$i++:++$d*$b/=$i:++$c*$a/=$i;echo$c<2&$d<3;

Essayez-le en ligne!

PHP , 87 octets

for(;$n<2;)for($a=$argn+$n++*$i=2;1<$a;)$a%$i?$i++:++$r[$n]*$a/=$i;echo$r[1]<2&$r[2]<3;

Essayez-le en ligne!

APL NARS, 23 caractères

{1≥⍵:0⋄(1=⍴π⍵)∧3>⍴π⍵+2}

Ici π⍵ renvoie le tableau de facteurs de ⍵ différent de 1; un test:

  f←{1≥⍵:0⋄(1=⍴π⍵)∧3>⍴π⍵+2}
  f 101
1 
  f 223
0 
  f 233
1 
  f 1
0
  f ¯10
0

Regex (ECMAScript), 31 octets

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

Essayez-le en ligne! (montrant tous les nombres premiers de Chen ≤ 1000)

Étant donné une chaîne de n x s, cette expression régulière correspondra si et seulement si n est un nombre premier de Chen.

Il affirme que n est supérieur à 2 et que la chaîne n'est pas de la forme. ((xx+)(\2(xx))*)(\1\4)+
Cette expression régulière a deux significations, selon le nombre de (\2(xx))répétitions.
Lorsqu'il est répété 0 fois, l'expression régulière peut être simplifiée (xx+)\1+, ce qui correspond aux nombres composites.
Lorsqu'il est répété un nombre de fois positif, l'expression régulière est équivalente à((xx+)(\2xx)+)(\1xx)+

Ce regex nécessite quelques explications, cependant, je fournirai peu de perspicacité.
Si vous passez par l'algèbre, vous trouvez que ((xx+)(\2xx)+)(\1xx)+correspond aux numéros du formulaire a*b*c-2où a≥4,b≥2,c≥2.
Il correspondra donc (presque) chaque fois que n +2 a plus de 2 facteurs premiers. (c'est-à-dire ni premier ni semi-premier)
Notez qu'il ne correspond pas à 6, 16 ou 25, mais que cela n'a pas d'importance, car ils sont tous composites.

Donc, (?!((xx+)(\2(xx))*)(\1\4)+$)cela correspondra tant que n n'est pas composite et que n +2 est soit premier, soit semi-premier.
Malheureusement, cela inclut 1 (et 0), nous vérifions donc que n est au moins 2 avecxx

Quelques "31 octets" différents sont:

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

Rubis , 49 41 octets

->n{/^(.?|((..+)\3+))(\2+|..)$/!~?l*n+=2}

Essayez-le en ligne!

Merci H.PWiz pour -8 octets

Comment?

Tout d'abord, obtenez une chaîne de 'l'n + 2 répétées. Ensuite, appliquez une expression régulière pour vérifier si:

• La longueur est de 2 ou 3 (.?)(..)
• La longueur est un nombre composite plus 2 ((..+)\1)(..)
• La longueur est un produit d'au moins 3 chiffres ((..+)\2)\1+

Les 2 parties regex génèrent un quatrième cas qui n'a pas de sens et qu'il est sûr d'ignorer (.?)\2+:, qui se résout en chaîne vide ou en un seul caractère car il \2est vide.

Julia, 59 octets

x->((0∉x%(2:x-1))&(length(find(x->x==0,(x+2)%(2:x)))<=2))

Pyt , 11 octets

3 * isprime (x) volé dans la réponse de Jonathan Allan

←Đṗ3*⇹2+ḋŁ>

Haskell , 163 octets

p k=last$(not$elem 0(map(mod k)[2..k-1])):[1>2|k<=1]
r=round
s n=p(r n)||any(\(a,b)->p(r a)&&p(r b))[(n/x,x)|x<-[2..n],n/x==(fromIntegral.r)n/x]
c n=p(r n)&&s(n+2)

Essayez-le en ligne!