TOC

Comment déterminer un nombre premier en Java

Une question très importante en mathématiques et en sécurité consiste à déterminer si un nombre est premier ou non. Ceci est très utile lors du cryptage d’un mot de passe. Dans ce tutoriel, vous allez apprendre à déterminer si un nombre est premier dans des cas simples.

Cas triviaux

Nous avons appris que les nombres sont premiers si leurs seuls diviseurs sont 1 et lui-même. Essentiellement, nous pouvons vérifier chaque entier de 1 à lui-même (exclusif) et vérifier s’il se divise de manière égale.

Par exemple, on pourrait être tenté d’exécuter cet algorithme:

…​.//checks whether an int is prime or not. boolean isPrime(int n) { for(int i=2;i<n;i++) { if(n%i==0) return false; } return true; } 

Cela ne semble pas mal au début, mais nous pouvons le faire plus rapidement.

Considérons que si 2 divise un entier n, alors (n/2) divise également n.

Cela nous dit que nous n'avons pas à essayer tous les entiers de 2 à n. Maintenant nous pouvons modifier notre algorithme:

....//checks whether an int is prime or not.
boolean isPrime(int n) {
    for(int i=2;2** i<n;i++) {
        if(n%i==0)
            return false;
    }
    return true;
}

Avec un codage plus efficace, nous remarquons qu’il ne faut en fait que remonter à la racine carrée de n, car si vous listez tous les facteurs d’un nombre, la racine carrée sera toujours au milieu (si ne pas être un entier, nous sommes toujours d’accord, nous pouvons simplement sur-approximer, mais notre code fonctionnera toujours).

Enfin, nous savons que 2 est le nombre le plus "étrange" - il s’agit même du seul nombre premier pair. Pour cette raison, il suffit de vérifier 2 séparément, puis de parcourir des nombres impairs jusqu’à la racine carrée de n. En fin de compte, notre code ressemblera à ceci:

…​.//checks whether an int is prime or not. boolean isPrime(int n) { //check if n is a multiple of 2 if (n%2==0) return false; //if not, then just check the odds for(int i=3;i** i⇐n;i+=2) { if(n%i==0) return false; } return true; } 

Comme vous pouvez le constater, nous sommes passés de la vérification de chaque entier (jusqu’à n pour découvrir qu’un nombre est premier) à la vérification de la moitié des entiers jusqu’à la racine carrée (les impairs, en réalité). C'est une énorme amélioration, surtout si les chiffres sont importants.

===  Répétitions

Supposons que vous écriviez un programme dans lequel vous êtes invité à vérifier si de nombreux nombres sont premiers; pas seulement une fois. Bien que notre programme ci-dessus soit hautement optimisé pour cet algorithme, il existe un autre moyen spécifiquement adapté à cette situation: le tamis principal.

Voici l'idée de base:

. Supposons que tout entier supérieur ou égal à 2 soit un nombre premier.

. Commencer au début de la liste, si le nombre est premier, rayer

chaque multiple de ce nombre de la liste. Ils ne sont pas premiers.

. Aller au numéro suivant, s'il est barré, sautez-le - ce n'est pas

premier. S'il n'est pas barré, il doit être premier, rayez ses multiples.

. Répéter

Voyons ce que cela signifie. Considérez la liste:

2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 …​ 

2 est premier ... rayer ses multiples. Notre liste ressemble maintenant à: +
**  2 3 4 5[ligne]**  6 **  7[ligne]**  8 **  9[ligne]**  10 **  11[ligne]**  12 **  13[ligne]**  14 **  15[ligne]**  16 **  17

[line-through]** 18**  19[line-through]** 20**  ...**

Vous pouvez voir pourquoi 2 est le seul nombre premier. En le faisant maintenant avec 3, nous rayons 6 (déjà barrés), 9, 12 (déjà barrés), 15, etc.

Finalement, votre liste ressemblera à ceci: +
**  2 3 4 5[ligne]**  6 **  7[ligne]**  8 ** [ligne]**  9 ** [ligne]**  10 **  11[ligne]**  12 **  13[ligne]**  14 **

[line-through]** 15** [line-through]** 16**  17[line-through]** 18**  19

[line-through]** 20**  ...**

Et nos nombres premiers sont ceux qui restent: (2,3,5,7,11,13,17,19,23,29, ...).

Dans le code, vous voudrez peut-être garder une trace de cette liste sous forme de tableau. Cela signifie que vous allez passer par n chiffres pour configurer ce "tamis", mais vous le compenserez en appelant à plusieurs reprises la fonction, car elle renverra une valeur instantanée, qu’un nombre soit premier ou non. Voici à quoi cela va ressembler. Bien sûr, vous pouvez le modifier vous-même pour répondre à vos besoins:

import java.util.Arrays;//global array just to keep track of it in this example, //but you can easily do this within another function. boolean[]primes=new boolean[10000]; //set up the primesieve public void fillSieve() { Arrays.fill(primes,true); //assume all integers are prime. primes[0]=primes[1]=false; //we know 0 and 1 are not prime. for (int i=2;i<primes.length;i) { //if the number is prime, //then go through all its multiples and make their values false. if(primes[i]) { for (int j=2;i** j<primes.length;j) { primes[i** j]=false; } } } }

public boolean isPrime(int n) { return primes[n];//simple, huh? } 

lien://tag/java/[java]lien://tag/nombre premier/[nombre premier]
Related