27

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.

code-golf number number-theory decision-problem primes Okx
la source

Pouvons-nous revenir Truepour la vérité et / 2ou Falsepour la fausse (valeurs de fausse incohérentes)?

M. Xcoder

@ Mr.Xcoder Jamais dit que vous ne pouviez pas

Okx

Pour un semi-premier, «exactement deux facteurs premiers» comptent-ils la multiplicité? Est-ce 2 * 2 * 2 * 3 * 3un semi-premier? Et alors 5 * 5?

Pas un arbre du

@Notatree 5*5est semi-premier, 2*2*2*3*3non. J'ai dit exactement deux.

Okx

Alors ça compte la multiplicité, alors? (Vous pourriez dire que cela 2*2*2*3*3a exactement deux facteurs premiers, à savoir 2et 3, et 5*5a un facteur premier, à savoir 5.) Peut-être pourriez-vous modifier cela dans la question?

Pas un arbre du

12

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

Fatalize
la source

1

J'ai attrapé Neil à exactement 48 000 répétitions, et maintenant vous à exactement 22 222: P

ETHproductions

11

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)

kalsowerus
la source

6

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.)

aras
la source

5

Gelée , 10 octets

+2ÆfL<3aÆP

Essayez-le en ligne!

Dennis
la source

5

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

Uriel
la source

>. <Outgolfed>. <

M. Xcoder

@ Mr.Xcoder en fait, j'ai posté le mien 5 minutes avant

Uriel

Ouais, je ne l'ai pas vu à cause de la mauvaise connexion Internet

M. Xcoder

3

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.

Jonathan Allan
la source

@Gryphon - J'ai pris le relais, il peut cependant être battu sans aucune importation.

Jonathan Allan

J'ai été dépassé! L' 3*isprime(n)astuce est ce que je cherchais pour nettoyer la déclaration conditionnelle.

Chase Vogeli

Ah, @icosahedron, je n'avais pas remarqué le vôtre, désolé - c'est tellement similaire que j'aurais juste commenté pour vous aider à améliorer le vôtre. N'hésitez pas à traiter cette réponse comme telle, faites le moi savoir et je supprimerai celle-ci.

Jonathan Allan

Je pense que sympy a une fonction primeomega .

alephalpha

@alephalpha Merci, juste mis à jour en 1.1 pour le voir, cela économisera des octets!

Jonathan Allan

3

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!

alephalpha
la source

3

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

Kevin Cruijssen
la source

La version itérative est juste un octet plus courte: n->{int N=n+2,f=0,F=0,d=1;for(;d++<n;f+=n%d<1?1:0)F+=N%d<1?1:0;return n>1&f<2&F<3;}.

Olivier Grégoire

2

Mathematica, 28 octets

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

alephalpha
la source

2

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évelopper l'extrait

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.

PurkkaKoodari
la source

Tu ne peux pas changer les deux &&en &? Depuis 0/1, les valeurs truey / falsey sont-elles également dans JS?

Kevin Cruijssen

@KevinCruijssen Cela semble fonctionner. Dommage |et &ne court-circuitez pas, cela pourrait économiser encore plus d'octets g.

PurkkaKoodari

2

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

Hirsute
la source

2

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é.

Titus
la source

1

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!

Chase Vogeli
la source

1

... notez également que vous n'en avez pas besoin f=, la création d'une fonction sans nom convient parfaitement au code-golf.

Jonathan Allan

1

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!

Jörg Hülsermann
la source

1

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

RosLuP
la source

1

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

H.PWiz
la source

1

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.

GB
la source

Vous pouvez fusionner les deux moitiés de votre |rapprochement: ^((..+)\2+)(\1+|..)$. Aussi, une belle coïncidence que vous avez tenté ce problème avec regex à un moment similaire à moi :)

H.PWiz

Je crois que vous pouvez utiliser .au lieu de .?puisque l'entrée est toujours au moins 1

H.PWiz

0

Julia, 59 octets

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

Tanj
la source

0

Pyt , 11 octets

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

←Đṗ3*⇹2+ḋŁ>

mudkip201
la source

0

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!

bogues
la source

Est-ce un Chen Prime?

Exemples:

Réponses:

Brachylog , 7 octets

Explication

05AB1E , 8 octets

Explication

ArnoldC , 1339 octets

Gelée , 10 octets

Pyth, 10 octets

Python avec sympy , 69 56 octets

Pari / GP , 29 octets

Java 8, 85 84 83 octets

Mathematica, 28 octets

JavaScript (ES6), 63 61 octets

Non golfé

Japt , 22 20 19 13 12 octets

PHP, 64 octets

Python 3 avec SymPy, 73 71 octets

PHP , 87 octets

PHP , 87 octets

APL NARS, 23 caractères

Regex (ECMAScript), 31 octets

Rubis , 49 41 octets

Comment?

Julia, 59 octets

Pyt , 11 octets

Haskell , 163 octets