Un numero è un numero primo di Chen se soddisfa due condizioni:

• È primo in sé
• Di per sé più due è un numero primo o un semi-primo.

Un numero primo è un numero in cui ha esattamente due divisori e quei divisori sono costituiti da se stesso e uno.

Un semi-primo è un numero che è il prodotto di due numeri primi. (Nota che 12 = 2 * 2 * 3 non è semi-primo, ma 25 = 5 * 5 lo è).

Il tuo compito è determinare se un numero è un numero primo di Chen. Dovresti generare qualsiasi valore di verità per sì e qualsiasi valore di falsa per no.

L'input sarà un numero intero maggiore o uguale a uno. Può anche essere preso come una stringa, una matrice di caratteri o una matrice o cifre.

Esempi:

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

Questo è OEIS A109611 .

Questo è, in parte, ispirato da Am I a Sophie Germain prime? che, sfortunatamente, è stato chiuso come duplicato, quindi sto postando una sfida in qualche modo correlata che non è un duplicato.

Brachylog , 7 byte

ṗ+₂ḋl≤2

Provalo online!

Spiegazione

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

05AB1E , 8 byte

p¹ÌÒg3‹*

Provalo online!

Spiegazione

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 byte

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

Provalo online!

(Questo è il mio primo post su codegolf.SE, per favore fatemi sapere se questo è formattato in modo errato. Mi rendo conto che questo numero di byte non è competitivo, questo è solo per divertimento.)

Gelatina , 10 byte

+2ÆfL<3aÆP

Provalo online!

Pyth, 10 byte

&P_Q>3lP+2

Provalo online!

Come?

&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 con sympy ,  69  56 byte

-13 byte grazie ad alephalpha (aggiornando a sympy 1.1 e usando primeomega(n+2)per sostituire sum(factorint(n+2).values()))

... subentra alla sottomissione cancellata di Gryphon.

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

Una funzione senza nome che ritorna Trueper i primi di Chen e Falsenon.

Conta i fattori n+2sommando le molteplicità del suo fattore primo.

Si noti che 3viene moltiplicato per isprime(n)prima del <confronto, quindi per i non primi nil codice verifica se n+2ha meno di 0fattori (sempre cedendo False), mentre per i primi ncontrolla se n+2è primo o semi-primo.

Pari / GP , 29 byte

Il 3*isprime(n)trucco è stato rubato dalla risposta di Jonathan Allan .

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

Provalo online!

Java 8, 85 84 83 byte

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 byte grazie a @ OlivierGrégoire utilizzando un approccio iterativo anziché ricorsivo.

Spiegazione:

Provalo qui.

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 byte

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

JavaScript (ES6), 63 61 byte

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>

Definisce una funzione fche accetta ncome argomento e restituisce il risultato. Sono molto contento di come gsi è rivelato; conta il numero di fattori primi in un numero.

Risparmio di 2 byte grazie al &trucco di Kevin Cruijssen .

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 byte

U°j ©2¨°Uk l

• 6 byte salvati grazie alla proposta di obarakon di un metodo diverso.

Provalo

PHP, 64 byte

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

stampe 0per verità, altri numeri interi per falsità. Esegui come pipe -nRo provalo online .

abbattersi

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

valore di falsy coerente, 65 byte:

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

stampe 1per verità e 0falsità.

Python 3 con SymPy, 73 71 byte

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

Provalo online!

Questa è una versione più complessa di una risposta pubblicata qui in precedenza, ma sembra essere stata eliminata.

Grazie a @JonathanAllan per aver salvato 2 byte!

PHP , 87 byte

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;

Provalo online!

PHP , 87 byte

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;

Provalo online!

APL NARS, 23 caratteri

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

Qui π⍵ restituisce la matrice di fattori di ⍵ diversa da 1; qualche 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

Provalo online! (mostra tutti i primi Chen ≤ 1000)

Data una stringa di n x s questa regex corrisponderà se e solo se n è un numero primo di Chen.

Afferma che n è maggiore di 2 e che la stringa non ha la forma ((xx+)(\2(xx))*)(\1\4)+
Questo regex ha due significati, a seconda di quante volte (\2(xx))si ripete.
Quando viene ripetuto 0 volte, è possibile semplificare il regex (xx+)\1+, che corrisponde ai numeri compositi.
Quando viene ripetuto un numero positivo di volte, la regex è equivalente a((xx+)(\2xx)+)(\1xx)+

Quel regex richiede qualche spiegazione, tuttavia, fornirò poche informazioni.
Se attraversi l'algebra, scopri che ((xx+)(\2xx)+)(\1xx)+corrisponde ai numeri del modulo in a*b*c-2cui a≥4,b≥2,c≥2.
Quindi corrisponderà (quasi) ogni volta che n +2 ha più di 2 fattori primi. (ovvero né primo né semi-primo)
Nota che non corrisponde a 6, 16 o 25, ma che questo non ha importanza, perché sono tutti compositi.

Quindi (?!((xx+)(\2(xx))*)(\1\4)+$)corrisponderà fintanto che n non è composito e n +2 è primo o semi-primo.
Sfortunatamente questo include 1 (e 0), quindi controlliamo che n sia almeno 2 conxx

Un paio di diversi "31 byte" sono:

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

Rubino , 49 41 byte

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

Provalo online!

Grazie H.PWiz per -8 byte

Come?

Per prima cosa, ottieni una serie di 'l'ripetute n + 2 volte. Quindi applicare una regex per verificare se:

• La lunghezza è 2 o 3 (.?)(..)
• La lunghezza è un numero composto più 2 ((..+)\1)(..)
• La lunghezza è un prodotto di almeno 3 numeri ((..+)\2)\1+

Le 2 parti regex generano un quarto caso che non ha senso ed è sicuro da ignorare (.?)\2+:, che si risolve in una stringa vuota o in un singolo carattere perché \2è vuota.

Julia, 59 byte

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

Pyt , 11 byte

3 * isprime (x) rubato dalla risposta di Jonathan Allan

←Đṗ3*⇹2+ḋŁ>

Haskell , 163 byte

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)

Provalo online!