Eine Zahl ist eine Chen-Primzahl, wenn sie zwei Bedingungen erfüllt:

• Es ist an sich Prime
• Selbst plus zwei ist entweder eine Primzahl oder eine Halbprimzahl.

Eine Primzahl ist eine Zahl, bei der genau zwei Teiler vorhanden sind und diese Teiler aus sich selbst und einem Teiler bestehen.

Eine Semi-Primzahl ist eine Zahl, die aus zwei Primzahlen besteht. (Beachten Sie, dass 12 = 2 * 2 * 3 kein Semi-Prime ist, sondern 25 = 5 * 5).

Ihre Aufgabe ist es, festzustellen, ob eine Zahl eine Chen-Primzahl ist. Sie sollten einen Wahrheitswert für yes und einen falschen Wert für no ausgeben.

Die Eingabe ist eine ganze Zahl größer oder gleich eins. Es kann auch als Zeichenfolge, Zeichenarray oder Array oder Ziffern verwendet werden.

Beispiele:

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

Dies ist OEIS A109611 .

Dies ist zum Teil inspiriert von Bin ich eine Sophie Germain Prime? was leider als Duplikat geschlossen wurde, also poste ich eine etwas verwandte Herausforderung, die kein Duplikat ist.

Brachylog , 7 Bytes

ṗ+₂ḋl≤2

Probieren Sie es online!

Erläuterung

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

05AB1E , 8 Bytes

p¹ÌÒg3‹*

Probieren Sie es online!

Erläuterung

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 Bytes

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

Probieren Sie es online!

(Dies ist mein erster Beitrag auf codegolf.SE, bitte lassen Sie mich wissen, wenn dies falsch formatiert ist. Ich stelle fest, dass diese Byteanzahl nicht wettbewerbsfähig ist, dies ist nur zum Spaß.)

Gelee , 10 Bytes

+2ÆfL<3aÆP

Probieren Sie es online!

Pyth, 10 Bytes

&P_Q>3lP+2

Probieren Sie es online!

Wie?

&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 mit Sympy ,  69  56 Bytes

-13 bytes dank alephalpha (durch upgraden auf sympy 1.1 und primeomega(n+2)ersetzen mit sum(factorint(n+2).values()))

... Übernahme von Gryphons gelöschtem Beitrag.

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

Eine unbenannte Funktion, die Truefür Chen-Primzahlen und Falseandere zurückgegeben wird.

Zählt die Faktoren, n+2indem die Multiplikationen des Primfaktors summiert werden.

Beachten Sie, dass vor dem Vergleich eine 3Multiplikation mit erfolgt. Wenn der Code nicht mit Primzahlen versehen ist , wird geprüft, ob er weniger als Faktoren enthält (immer ergibt ), und bei Primzahlen wird geprüft, ob es sich um Primzahlen oder Halbprimzahlen handelt.isprime(n)<nn+20Falsenn+2

Pari / GP , 29 Bytes

Der 3*isprime(n)Trick wird Jonathan Allans Antwort gestohlen .

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

Probieren Sie es online!

Java 8, 85 84 83 Bytes

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 Bytes dank @ OlivierGrégoire mit einem iterativen Ansatz anstelle von rekursiv.

Erläuterung:

Probieren Sie es hier aus.

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 Bytes

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

JavaScript (ES6), 63 61 Bytes

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>

Definiert eine Funktion f, die nals Argument verwendet und das Ergebnis zurückgibt. Ich bin sehr zufrieden mit gdem Ergebnis. es zählt die Anzahl der Primfaktoren in einer Zahl.

2 Bytes sparen dank Kevin Cruijsens &Trick.

Ungolfed

Ω = (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 Bytes

U°j ©2¨°Uk l

• 6 Bytes gespart dank Obarakons Vorschlag einer anderen Methode.

Probier es aus

PHP, 64 Bytes

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

druckt 0für wahr, andere ganze Zahlen für falsch. Laufen Sie als Pipe mit -nRoder versuchen Sie es online .

Nervenzusammenbruch

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

konsistenter falscher Wert, 65 Bytes:

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

druckt 1für wahr und 0für falsch.

Python 3 mit SymPy, 73 71 Bytes

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

Probieren Sie es online!

Dies ist eine weiter fortgeschrittene Version einer Antwort, die hier früher gepostet wurde, aber sie scheint gelöscht worden zu sein.

Vielen Dank an @ JonathanAllan für das Speichern von 2 Bytes!

PHP , 87 Bytes

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;

Probieren Sie es online!

PHP , 87 Bytes

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;

Probieren Sie es online!

APL NARS, 23 Zeichen

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

Hier gibt π⍵ die Reihe von Faktoren von ⍵ zurück, die sich von 1 unterscheiden; ein 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 Byte

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

Probieren Sie es online! (zeigt alle Chen-Primzahlen ≤ 1000)

Bei einer Folge von n x s stimmt dieser reguläre Ausdruck genau dann überein, wenn n eine Chen-Primzahl ist.

Es wird behauptet, dass n größer als 2 ist und dass die Zeichenfolge nicht die Form hat. ((xx+)(\2(xx))*)(\1\4)+
Dieser reguläre Ausdruck hat zwei Bedeutungen, je nachdem, wie oft er (\2(xx))wiederholt wird.
Wenn es 0-mal wiederholt wird, kann der reguläre Ausdruck vereinfacht werden (xx+)\1+, was mit zusammengesetzten Zahlen übereinstimmt.
Wenn es eine positive Anzahl von Malen wiederholt wird, entspricht der reguläre Ausdruck((xx+)(\2xx)+)(\1xx)+

Dieser reguläre Ausdruck bedarf einiger Erklärungen, ich werde jedoch nur einen kleinen Einblick gewähren.
Wenn Sie durch die Algebra gehen, finden Sie, dass ((xx+)(\2xx)+)(\1xx)+Zahlen der Form a*b*c-2wo übereinstimmen a≥4,b≥2,c≥2.
Es wird also (fast) passen, wenn n +2 mehr als 2 Primfaktoren hat. (dh weder Primzahl noch Semi-Primzahl)
Beachten Sie, dass es nicht mit 6, 16 oder 25 übereinstimmt, aber dass dies keine Rolle spielt, da sie alle zusammengesetzt sind.

Also (?!((xx+)(\2(xx))*)(\1\4)+$)wird passen, solange n nicht zusammengesetzt ist und n +2 entweder Prim oder Semi-Prim ist.
Leider enthält dies 1 (und 0), so dass wir dann überprüfen, dass n mindestens 2 mit istxx

Ein paar verschiedene "31-Bytes" sind:

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

Ruby , 49 41 Bytes

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

Probieren Sie es online!

Danke H.PWiz für -8 Bytes

Wie?

Holen Sie sich als erstes eine Folge von 'l'n + 2-mal wiederholt. Wenden Sie dann einen regulären Ausdruck an, um zu überprüfen, ob:

• Länge ist 2 oder 3 (.?)(..)
• Länge ist eine zusammengesetzte Zahl plus 2 ((..+)\1)(..)
• Länge ist ein Produkt von mindestens 3 Zahlen ((..+)\2)\1+

Die 2 regulären Ausdrücke erzeugen einen vierten Fall, der keinen Sinn ergibt und ignoriert werden (.?)\2+kann:, der sich in eine leere Zeichenfolge oder ein einzelnes Zeichen auflöst, weil \2es leer ist.

Julia, 59 Bytes

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

Pyt , 11 Bytes

3 * isprime (x) wurde Jonathan Allans Antwort gestohlen

←Đṗ3*⇹2+ḋŁ>

Haskell , 163 Bytes

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)

Probieren Sie es online!