Um número é um primo Chen se satisfizer duas condições:

• É primo em si
• Em si, mais dois, é um primo ou um semi-primo.

Um primo é um número em que possui exatamente dois divisores e esses divisores consistem em si e um.

Um semi-primo é um número que é o produto de dois primos. (Observe que 12 = 2 * 2 * 3 não é semi-primo, mas 25 = 5 * 5 é).

Sua tarefa é determinar se um número é um primo Chen. Você deve gerar qualquer valor verdadeiro para yes e qualquer valor falso para no.

A entrada será qualquer número inteiro maior ou igual a um. Também pode ser tomado como uma sequência de caracteres, uma matriz de caracteres ou uma matriz ou dígitos.

Exemplos:

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

Este é o OEIS A109611 .

Isso é, em parte, inspirado em Sou uma prima da Sophie Germain? que, infelizmente, foi fechado como duplicado, então estou postando um desafio relacionado que não é duplicado.

Braquilog , 7 bytes

ṗ+₂ḋl≤2

Experimente online!

Explicação

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

05AB1E , 8 bytes

p¹ÌÒg3‹*

Experimente online!

Explicação

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

Experimente online!

(Este é o meu primeiro post no codegolf.SE, informe-nos se este estiver formatado incorretamente. Percebo que essa contagem de bytes não é competitiva, é apenas diversão.)

Gelatina , 10 bytes

+2ÆfL<3aÆP

Experimente online!

Pitão, 10 bytes

&P_Q>3lP+2

Experimente online!

Quão?

&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 com sympy ,  69  56 bytes

-13 bytes graças ao alephalpha (atualizando para o sympy 1.1 e usando primeomega(n+2)para substituir sum(factorint(n+2).values()))

... substituindo a submissão excluída do Gryphon.

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

Uma função sem nome retornando Truepara primos Chen e Falseoutros.

Conta os fatores n+2somando as multiplicidades de seus fatores primos.

Observe que 3é multiplicado por isprime(n)antes da <comparação, portanto, para não-prime, no código testa se n+2possui menos de 0fatores (sempre produzindo False), enquanto para o prime nverifica se n+2é primo ou semi-primo.

Pari / GP , 29 bytes

O 3*isprime(n)truque é roubado da resposta de Jonathan Allan .

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

Experimente 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 graças a @ OlivierGrégoire usando uma abordagem iterativa em vez de recursiva.

Explicação:

Experimente aqui.

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 uma função fque aceita ncomo argumento e retorna o resultado. Estou muito feliz com o gresultado; conta o número de fatores primos em um número.

Economiza 2 bytes graças ao &truque de 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 bytes

U°j ©2¨°Uk l

• 6 bytes salvos graças à sugestão de obarakon de um método diferente.

Teste-o

PHP, 64 bytes

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

imprime 0por verdade, outros números inteiros por falsidade. Execute como pipe -nRou experimente online .

demolir

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 consistente, 65 bytes:

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

imprime 1por verdade e 0por falsidade.

Python 3 com SymPy, 73 71 bytes

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

Experimente online!

Esta é uma versão mais detalhada de uma resposta postada aqui anteriormente, mas parece ter sido excluída.

Obrigado a @ JonathanAllan por salvar 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;

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

Experimente online!

APL NARS, 23 caracteres

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

Aqui π⍵ retorna a matriz de fatores de ⍵ diferente de 1; algum teste:

  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

Experimente online! (mostrando todos os primos de Chen ≤ 1000)

Dada uma sequência de n x s, esse regex corresponderá se e somente se n for um primo Chen.

Ele afirma que n é maior que 2 e que a sequência não tem a forma ((xx+)(\2(xx))*)(\1\4)+
Este regex tem dois significados, dependendo de quantas vezes (\2(xx))é repetido.
Quando é repetido 0 vezes, a regex pode ser simplificada para (xx+)\1+, o que corresponde aos números compostos.
Quando é repetido um número positivo de vezes, o regex é equivalente a((xx+)(\2xx)+)(\1xx)+

Esse regex requer alguma explicação, no entanto, fornecerei pouca percepção.
Se você percorrer a álgebra, encontrará que ((xx+)(\2xx)+)(\1xx)+corresponde aos números da forma em a*b*c-2que a≥4,b≥2,c≥2.
Portanto, ele corresponderá (quase) sempre que n +2 tiver mais de 2 fatores primos. (ou seja, nem prime nem semi-prime)
Observe que não corresponde a 6, 16 ou 25, mas isso não importa, porque todos são compostos.

Portanto (?!((xx+)(\2(xx))*)(\1\4)+$), corresponderá desde que n não seja composto e n +2 seja primo ou semi-primo.
Infelizmente, isso inclui 1 (e 0), então verificamos que n é pelo menos 2 comxx

Alguns "31 byters" diferentes são:

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

Ruby , 49 41 bytes

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

Experimente online!

Obrigado H.PWiz por -8 bytes

Quão?

Primeiro, obtenha uma sequência 'l'repetida de n + 2 vezes. Em seguida, aplique uma regex para verificar se:

• O comprimento é 2 ou 3 (.?)(..)
• Comprimento é um número composto mais 2 ((..+)\1)(..)
• Comprimento é um produto de pelo menos três números ((..+)\2)\1+

As duas partes de regex geram um quarto caso que não faz sentido e é seguro ignorar (.?)\2+:, que resolve esvaziar uma string ou um único caractere porque \2está vazio.

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) roubado da resposta 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)

Experimente online!