Comment lister les nombres premiers inférieurs à 1000 en utilisant le Crible d'Ératosthène

Sun, 09 Apr 2023 12:54:24 +0900

Qu’est-ce que le Crible d’Ératosthène ?

Le Crible d’Ératosthène est un algorithme utilisé pour trouver tous les nombres premiers jusqu’à une limite donnée. L’algorithme est simple et peut être implémenté via les étapes suivantes :

Créer un tableau booléen de N éléments et initialiser tous les éléments à vrai (true).
Définir les 0ème et 1er éléments du tableau sur faux (false) (car 0 et 1 ne sont pas premiers).
Si le 2ème élément du tableau est vrai, afficher 2 comme nombre premier.
Définir tous les multiples de 2 supérieurs ou égaux à $2^2$ sur faux (*).
Si le 3ème élément du tableau est vrai, afficher 3 comme nombre premier.
Définir tous les multiples de 3 supérieurs ou égaux à $3^2$ sur faux.
Répéter le même processus pour les 4ème, 5ème, …, et N-ième éléments.

La raison pour laquelle on commence à marquer comme faux à partir du carré du nombre est que les nombres inférieurs au carré ont déjà été traités lors des étapes précédentes.

Implémentation en Rust

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


fn main() {
 let n = 1000;
 let mut is_prime = vec![true; n+1];
 is_prime[0] = false;
 is_prime[1] = false;
 for i in 2..=n {
 if is_prime[i] {
 println!("{}", i);
 let mut j = i * i;
 while j <= n {
 is_prime[j] = false;
 j += i;
 }
 }
 }
}

Version légèrement optimisée

Nous pouvons optimiser légèrement l’implémentation en considérant les points suivants :

Initialiser le tableau à faux (false) au lieu de vrai (true) (cela est plus rapide).
Puisque les multiples de 2 ne sont pas des nombres premiers, ignorer l’étape visant à définir les multiples de 2 sur faux.
Il n’est pas nécessaire de boucler jusqu’à n ; trouver les nombres premiers jusqu’à la racine carrée de n suffit pour trouver tous les nombres premiers inférieurs ou égaux à n.

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


fn main() {
 let n = 1000;
 let mut is_prime = vec![false; n+1];
 is_prime[2] = true;
 for i in (3..=n).step_by(2) {
 is_prime[i] = true;
 }
 for i in 3..=((n as f64).sqrt() as usize) {
 if is_prime[i] {
 let mut j = i * i;
 while j <= n {
 is_prime[j] = false;
 j += i * 2;
 }
 }
 }
 for i in (2..=n).filter(|&x| is_prime[x]) {
 println!("{}", i);
 }
}

Référence

Crible d’Ératosthène (Wikipedia)

Crible D'Ératosthène on kenji.blog

Comment lister les nombres premiers inférieurs à 1000 en utilisant le Crible d'Ératosthène

Qu’est-ce que le Crible d’Ératosthène ?

Implémentation en Rust

Version légèrement optimisée

Référence