Un número es un primo Chen si cumple dos condiciones:

• Es primo en sí
• Sí más dos es un primo o un semi-primo.

Un primo es un número donde tiene exactamente dos divisores y esos divisores consisten en sí mismo y uno.

Un semi-primo es un número que es el producto de dos primos. (Tenga en cuenta que 12 = 2 * 2 * 3 no es semi-prime, pero 25 = 5 * 5 sí).

Su tarea es determinar si un número es un primo Chen. Debe generar cualquier valor verdadero para sí y cualquier valor falso para no.

La entrada será cualquier número entero mayor o igual a uno. También se puede tomar como una cadena, una matriz de caracteres o una matriz o dígitos.

Ejemplos:

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

Este es OEIS A109611 .

Esto está, en parte, inspirado en ¿Soy una prima de Sophie Germain? que, desafortunadamente, se cerró como un duplicado, por lo que publico un desafío relacionado que no es un duplicado.

Brachylog , 7 bytes

ṗ+₂ḋl≤2

Pruébalo en línea!

Explicación

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

05AB1E , 8 bytes

p¹ÌÒg3‹*

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

(Esta es mi primera publicación en codegolf.SE, por favor avíseme si está formateada incorrectamente. Me doy cuenta de que este recuento de bytes no es competitivo, esto es solo por diversión).

Jalea , 10 bytes

+2ÆfL<3aÆP

Pruébalo en línea!

Pyth, 10 bytes

&P_Q>3lP+2

Pruébalo en línea!

¿Cómo?

&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 bytes

-13 bytes gracias a alephalpha (actualizando a sympy 1.1 y usando primeomega(n+2)para reemplazar sum(factorint(n+2).values()))

... tomando el relevo del envío eliminado de Gryphon.

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

Una función sin nombre que regresa Truepara los primos Chen y Falseotros

Cuenta los factores n+2sumando las multiplicidades de su factor primo.

Tenga en cuenta que 3se multiplica por isprime(n)antes de que <se haga la comparación, por lo tanto, para nlas pruebas de código no primas si n+2tiene menos de 0factores (siempre ceden False), mientras que para primas nverifica si n+2es primo o semiprime.

Pari / GP , 29 bytes

El 3*isprime(n)truco es robado de la respuesta de Jonathan Allan .

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

Pruébalo en línea!

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 gracias a @ OlivierGrégoire mediante el uso de un enfoque iterativo en lugar de recursivo.

Explicación:

Pruébalo aquí

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>

Define una función fque toma ncomo argumento y devuelve el resultado. Estoy muy contento con cómo gresultó; cuenta el número de factores primos en un número.

2 bytes ahorrados gracias al &truco de Kevin Cruijssen .

Sin 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 bytes

U°j ©2¨°Uk l

• 6 bytes guardados gracias a la sugerencia de obarakon de un método diferente.

Pruébalo

PHP, 64 bytes

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

impresiones 0para la verdad, otros enteros para la falsedad. Ejecutar como tubería con -nRo probarlo en línea .

Descompostura

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

valor falso falso, 65 bytes:

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

impresiones 1para la verdad y 0para la falsedad.

Python 3 con SymPy, 73 71 bytes

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

Pruébalo en línea!

Esta es una versión más desarrollada de una respuesta publicada aquí anteriormente, pero parece que se ha eliminado.

¡Gracias a @JonathanAllan por guardar 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;

Pruébalo en línea!

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;

Pruébalo en línea!

APL NARS, 23 caracteres

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

Aquí π⍵ devuelve la matriz de factores de ⍵ diferentes de 1; alguna prueba:

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

Regex (ECMAScript), 31 bytes

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

Pruébalo en línea! (mostrando todos los primos de Chen ≤ 1000)

Dada una cadena de n x s, esta expresión regular coincidirá si y solo si n es un primo Chen.

Afirma que n es mayor que 2 y que la cadena no tiene la forma. ((xx+)(\2(xx))*)(\1\4)+
Esta expresión regular tiene dos significados, dependiendo de cuántas veces (\2(xx))se repita.
Cuando se repite 0 veces, la expresión regular se puede simplificar para (xx+)\1+que coincida con los números compuestos.
Cuando se repite un número positivo de veces, la expresión regular es equivalente a((xx+)(\2xx)+)(\1xx)+

Esa expresión regular requiere alguna explicación, sin embargo, proporcionaré poca información.
Si revisa el álgebra, encuentra que ((xx+)(\2xx)+)(\1xx)+coincide con los números de la forma a*b*c-2donde a≥4,b≥2,c≥2.
Por lo tanto, coincidirá (casi) siempre que n +2 tenga más de 2 factores primos. (es decir, ni prime ni semi-prime)
Tenga en cuenta que no coincide con 6, 16 o 25, pero que esto no importa, porque todos son compuestos.

Entonces (?!((xx+)(\2(xx))*)(\1\4)+$)coincidirá siempre que n no sea compuesto, y n +2 sea primo o semi-primo.
Desafortunadamente, esto incluye 1 (y 0), por lo que luego verificamos que n es al menos 2 conxx

Un par de diferentes "31-byters" son:

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

Ruby , 49 41 bytes

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

Pruébalo en línea!

Gracias H.PWiz por -8 bytes

¿Cómo?

Lo primero es obtener una cadena de 'l'n + 2 veces repetidas. Luego aplique una expresión regular para verificar si:

• La longitud es de 2 o 3 (.?)(..)
• La longitud es un número compuesto más 2 ((..+)\1)(..)
• La longitud es un producto de al menos 3 números ((..+)\2)\1+

Las 2 partes regex generan un cuarto caso que no tiene sentido y es seguro ignorar: (.?)\2+que resuelve una cadena vacía o un solo carácter porque \2está vacío.

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) robado de la respuesta de Jonathan Allan

←Đṗ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)

Pruébalo en línea!