Primzahlen on kenji.blog

C-Code zur Generierung von Primzahlen

Sat, 24 Aug 2024 09:38:10 +0900

Nachfolgend finden Sie einen einfachen C-Code, der Primzahlen innerhalb eines bestimmten Bereichs generiert. In diesem Beispiel zählen wir Primzahlen von 1 bis n auf.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


#include <stdio.h>
#include <stdbool.h>

bool isPrime(int num) {
 if (num <= 1) return false;
 if (num <= 3) return true;
 if (num % 2 == 0 || num % 3 == 0) return false;

 for (int i = 5; i * i <= num; i += 6) {
 if (num % i == 0 || num % (i + 2) == 0) return false;
 }
 return true;
}

void printPrimes(int n) {
 printf("2 ");
 for (int i = 3; i <= n; i += 2) {
 if (isPrime(i)) {
 printf("%d ", i);
 }
 }
 printf("\n");
}

int main() {
 int n;
 printf("Bitte geben Sie den Maximalwert des Bereichs ein, um Primzahlen zu generieren: ");
 scanf("%d", &n);
 printf("Die Primzahlen von 1 bis %d sind wie folgt:\n", n);
 printPrimes(n);
 return 0;
}

Dieser Code funktioniert wie folgt:

Funktion isPrime: Bestimmt, ob eine gegebene Zahl eine Primzahl ist. Aus Effizienzgründen wird zunächst geprüft, ob sie durch 2 und 3 teilbar ist, und dann in Vielfachen von 6 weitergeprüft.
Funktion printPrimes: Gibt die Primzahlen innerhalb eines bestimmten Bereichs aus. Die 2 wird zuerst ausgegeben, und dann werden nur ungerade Zahlen überprüft.
Funktion main: Fordert den Benutzer auf, den Maximalwert des Bereichs einzugeben, und gibt die Primzahlen innerhalb dieses Bereichs aus.

Wenn Sie diesen Code kompilieren und ausführen, werden die Primzahlen innerhalb des angegebenen Bereichs angezeigt.

Wie man Primzahlen unter 1000 mit dem Sieb des Eratosthenes auflistet

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

Was ist das Sieb des Eratosthenes?

Das Sieb des Eratosthenes ist ein Algorithmus, mit dem alle Primzahlen bis zu einem bestimmten Grenzwert gefunden werden können. Der Algorithmus ist einfach und kann durch die folgenden Schritte implementiert werden:

Erstellen Sie ein boolesches Array mit N Elementen und initialisieren Sie alle Elemente auf wahr (true).
Setzen Sie das nullte und das erste Element des Arrays auf falsch (false) (da 0 und 1 keine Primzahlen sind).
Wenn das 2. Element des Arrays wahr ist, geben Sie 2 als Primzahl aus.
Setzen Sie alle Vielfachen von 2 ab $2^2$ auf falsch (*).
Wenn das 3. Element des Arrays wahr ist, geben Sie 3 als Primzahl aus.
Setzen Sie alle Vielfachen von 3 ab $3^2$ auf falsch.
Wiederholen Sie den gleichen Vorgang für das 4., 5., …, und N-te Element.

Der Grund, warum die Elemente ab dem Quadrat des Wertes auf falsch gesetzt werden, liegt daran, dass Zahlen, die kleiner als das Quadrat sind, bereits in vorherigen Schritten verarbeitet wurden.

Implementierung in 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;
 }
 }
 }
}

Leicht optimierte Version

Wir können die Implementierung unter Berücksichtigung der folgenden Punkte leicht optimieren:

Initialisieren Sie das Array mit falsch (false) statt mit wahr (true) (das ist schneller).
Da Vielfache von 2 keine Primzahlen sind, überspringen Sie den Schritt, bei dem die Vielfachen von 2 auf falsch gesetzt werden.
Es ist nicht notwendig, bis n zu iterieren; es reicht aus, die Primzahlen bis zur Quadratwurzel von n zu berechnen, um alle Primzahlen zu finden, die kleiner oder gleich n sind.

 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);
 }
}

Referenz

Sieb des Eratosthenes (Wikipedia)

Aufzählung von Primzahlen in Rust

Fri, 09 Sep 2022 07:08:49 +0900

Ich habe ein Programm geschrieben, um Primzahlen in Rust aufzuzählen.

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


fn main() {
 let max = 1000;
 let mut primes = vec![2];
 let mut n = 3;
 loop {
 let mut is_prime = true;
 for p in &primes {
 if n % p == 0 {
 is_prime = false;
 break;
 }
 }
 if is_prime {
 primes.push(n);
 }
 n += 2;
 if n > max {
 break;
 }
 }
 for p in &primes {
 println!("{}", p);
 }
}