L'une de mes définitions préférées des nombres premiers est la suivante:

• 2 est le plus petit nombre premier.

• Les nombres supérieurs à 2 sont premiers s'ils ne sont pas divisibles par un plus petit nombre premier.

Cependant cette définition semble arbitraire, pourquoi 2? Pourquoi pas un autre numéro? Eh bien, essayons d'autres nombres qui définiront n-prime de telle sorte que

• n est le plus petit n-premier.

• Les nombres supérieurs à n sont n-premiers s'ils ne sont pas divisibles par un n-premier plus petit.

Tâche

La tâche ici est d'écrire un programme qui prend deux entrées, un entier positif n et un entier positif a . Il décidera alors si a est n -prime. Votre programme doit afficher deux valeurs distinctes, une pour «oui, c'est n-prime» et une pour «non, ce n'est pas n-prime».

C'est une question de code-golf donc les réponses seront notées en octets avec moins d'octets étant mieux.

Des tests

Voici les listes des 31 premiers nombres premiers pour n = 2 à n = 12 (1 est le seul nombre à 1 nombre premier)

n=2: [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127]
n=3: [3,4,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127]
n=4: [4,5,6,7,9,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113]
n=5: [5,6,7,8,9,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113]
n=6: [6,7,8,9,10,11,13,15,17,19,23,25,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107]
n=7: [7,8,9,10,11,12,13,15,17,19,23,25,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107]
n=8: [8,9,10,11,12,13,14,15,17,19,21,23,25,29,31,35,37,41,43,47,49,53,59,61,67,71,73,79,83,89,97]
n=9: [9,10,11,12,13,14,15,16,17,19,21,23,25,29,31,35,37,41,43,47,49,53,59,61,67,71,73,79,83,89,97]
n=10: [10,11,12,13,14,15,16,17,18,19,21,23,25,27,29,31,35,37,41,43,47,49,53,59,61,67,71,73,79,83,89]
n=11: [11,12,13,14,15,16,17,18,19,20,21,23,25,27,29,31,35,37,41,43,47,49,53,59,61,67,71,73,79,83,89]
n=12: [12,13,14,15,16,17,18,19,20,21,22,23,25,27,29,31,33,35,37,41,43,47,49,53,55,59,61,67,71,73,77]

Haskell , 45 octets

n!a=not$any(n!)[x|x<-[n..a-1],mod a x<1]||n>a

Essayez-le en ligne!

Je définis une belle fonction récursive (!):

n!avérifie si un facteur de a, dans la plage [n,a-1], est un n-prime. Ensuite, il annule le résultat. Il s'assure également quen>a

Python 2 , 39 37 octets

Merci à Halvard Hummel pour -2 octets.

f=lambda n,i:n==i or i>i%n>0<f(n+1,i)

Essayez-le en ligne!

Python 3 , 45 octets

lambda i,k:(i>k)<all(k%r for r in range(i,k))

Essayez-le en ligne!

Comment ça marche

Cela prend deux entiers en entrée, i et k . Vérifiez d'abord si k ≥ i . Génère ensuite la plage [i, k) et pour chaque entier N dans cette plage, vérifie si N est coprime à k . Si les deux conditions sont remplies, alors k est un i -prime.

Husk , 6 5 octets

εf≥⁰Ḋ

Essayez-le en ligne! ou voir les résultats jusqu'à 80 .

Merci à Leo pour -1 octet.

Explication

εf≥⁰Ḋ  Inputs are n and k.
    Ḋ  Divisors of k.
 f     Keep those that are
  ≥⁰   at least n.
ε      Is the result a one-element list?

R , 44 37 octets

function(a,n)a==n|a>n&all(a%%n:(a-1))

Essayez-le en ligne!

-7 octets grâce à Giuseppe

Renvoie TRUEsi

• aest égal à nou ( a==n|)
• aest supérieur à n et ( a>n&) pour chaque nombre k de nà a-1, an'est pas divisible par k ( all(a%%n:(a-1)))

Retourne FALSEautrement

J, 30 octets

>:*(-{1=[:+/0=[:|/~]+i.@[)^:>:

Essayez-le en ligne!

Prend la valeur de départ comme argument de droite et la valeur à vérifier dans l'argument de gauche.

Je me suis trompé à l'origine et je n'ai pas tenu compte des arguments laissés moins que le nombre premier de départ. Je suis quelque peu mécontent de la longueur de ma solution maintenant.

Explication

Soit xl'argument de gauche (la valeur à vérifier) ​​et yl'argument de droite (le premier de départ).

>:*(-{1=[:+/0=[:|/~]+i.@[)^:>:
                          ^:>:  Execute left argument if x >= y
                     i.@[         Create range [0..x]
                   ]+             Add y to it (range now: [y..x+y])
                |/~               Form table of residues
            0=                    Equate each element to 0
          +/                      Sum columns
      1=                          Equate to 1
    -{                            Take the element at position x-y
>:*                             Multiply by result of x >= y

Remarques

L'élément en position x-yest le résultat d'un test de primalité pour x(puisque nous avons ajouté yà la plage d'origine).

La multiplication par x >: ygarantit que nous obtenons une valeur de falsey ( 0) pour xmoins de y.

JavaScript (ES6), 33 32 30 octets

Prend des entrées dans la syntaxe de currying (n)(a). Renvoie un booléen.

n=>p=(a,k=a)=>k%--a?p(a,k):a<n

Démo

let f =

n=>p=(a,k=a)=>k%--a?p(a,k):a<n

for(n = 2; n <= 12; n++) {
  for(a = n, P = []; P.length < 31; a++) {
    f(n)(a) && P.push(a);
  }
  O.innerText += 'n=' + n + ': ' + P.join(',') + '\n';
}

<pre id=O></pre>

Haskell , 30 octets

2 octets économisés grâce à l'idée de H.PWiz qui a été empruntée à la réponse de flawr

n!a=[1]==[1|0<-mod a<$>[n..a]]

Essayez-le en ligne!

Ok depuis que ça fait un moment, et la seule réponse Haskell jusqu'à présent est de 45 btyes, j'ai décidé de poster ma propre réponse.

Explication

Cette fonction vérifie que le seul nombre entre n et un qui a est divisible par est un lui - même.

Maintenant, la définition ne mentionne que n -primes inférieurs à a , alors pourquoi vérifions -nous tous ces nombres supplémentaires? N'aurons- nous pas de problèmes quand a est divisible par un composé n plus grand que n ?

Nous ne le ferons pas car s'il existe un n -composite supérieur à n, il doit être divisible par un n -prime plus petit par définition. Ainsi, s'il divise a , le plus petit n -prime doit l' être.

Si a est inférieur à n, il [n..a] ne peut []donc pas être égal, [1]ce qui entraîne l'échec de la vérification.

Gelée , 8 octets

rṖ⁴%$Ạ×<

Essayez-le en ligne!

Pip , 23 19 14 octets

b>=a&$&b%(a,b)

La méthode la plus courte est un portage de la réponse Python de M. Xcoder . Prend le plus petit nombre premier et le nombre à tester comme arguments de ligne de commande. Essayez-le en ligne!

C, 55 octets

f(n,a,i){for(i=a;i-->n;)a%i||f(n,i)&&(i=0);return-1<i;}

Essayez-le en ligne!

53 octets si plusieurs valeurs de retour véridiques sont autorisées:

f(n,a,i){for(i=a;i-->n;)a%i||f(n,i)&&(i=0);return~i;}

Essayez-le en ligne!

dc , _{40 34} 37 octets

[0p3Q]sf?se[dler%0=f1+dle>u]sudle>u1p

J'aurais inclus un lien TIO, mais TIO semble porter une distribution défectueuse de dcvoir comment cela fonctionne comme prévu sur mon système, mais la Qcommande fonctionne par erreur sur TIO. Au lieu de cela, voici un lien vers un bashterrain d'essai avec une version fonctionnant correctement de dc:

Démo!

APL (Dyalog) , 24 octets

{⍵∊o/⍨1=+/¨0=o|⍨⊂o←⍺↓⍳⍵}

Essayez-le en ligne!

Comment?

⍳⍵- 1àa

o←⍺↓- nà a, enregistrer danso

o|⍨⊂o- modulo chaque élément oavec chaque élémento

0=- vérifier où il est égal 0(divise)

+/¨ - additionner le nombre de divisions

1= - si nous n'en avons qu'un, le nombre n'est divisé que par lui-même

o/⍨ - donc on garde ces occurrences

⍵∊- est adans ce tableau résiduel?

JavaScript (Node.js) , 27 octets

i=>f=n=>i==n||i>i%n&&f(n+1)

Essayez-le en ligne!

Port de ma réponse Python, prend une entrée dans la syntaxe de curry: m(number)(first prime)

JavaScript ES5, 34 octets

for(a=i=(p=prompt)();a%--i;);i<p()

Ajouter ++ , 20 octets

L,2Dx@rBcB%B]b*!!A>*

Essayez-le en ligne!

L,   - Create a lambda function
     - Example arguments:  [5 9]
  2D - Copy below; STACK = [5 9 5]
  x  - Repeat;     STACK = [5 9 [9 9 9 9 9]]
  @  - Reverse;    STACK = [[9 9 9 9 9] 5 19] 
  r  - Range;      STACK = [[9 9 9 9 9] [5 6 7 8 9]]
  Bc - Zip;        STACK = [[9 5] [9 6] [9 7] [9 8] [9 9]]
  B% - Modulo;     STACK = [4 3 2 1]
  B] - Wrap;       STACK = [[4 3 2 1]]
  b* - Product;    STACK = [24]
  !! - Boolean;    STACK = [1]
  A  - Arguments;  STACK = [1 5 9]
  >  - Greater;    STACK = [1 1]
  *  - Product;    STACK = [1]