素数 on kenji.blog

生成素数的C语言代码

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

以下是一个简单的C语言代码，用于生成指定范围内的素数。在这个例子中，我们列举出1到n之间的素数。

 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("请输入生成素数范围的最大值: ");
 scanf("%d", &n);
 printf("1到%d的素数如下:\n", n);
 printPrimes(n);
 return 0;
}

这段代码的运行机制如下：

isPrime函数：判断给定的数是否为素数。出于效率考虑，首先检查是否能被2和3整除，然后步长为6进行后续检查。
printPrimes函数：输出指定范围内的素数。首先输出2，之后只检查奇数。
main函数：接收用户输入的范围最大值，并输出该范围内的素数。

编译并运行此代码后，将会显示指定范围内的素数。

使用埃拉托斯特尼筛法列举1000以下的素数

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

什么是埃拉托斯特尼筛法

埃拉托斯特尼筛法是一种用于列举小于等于某个数值的所有素数的算法。算法非常简单，可以通过以下步骤实现：

创建一个包含 N 个元素的 bool 值数组，并将所有元素初始化为 true
将数组的第 0 个和第 1 个元素设为 false（因为 0 和 1 不是素数）
如果数组的第 2 个元素为 true，则将 2 作为素数输出
将数组中 $2^2$ 及以上的所有 2 的倍数位置的元素设为 false※
如果数组的第 3 个元素为 true，则将 3 作为素数输出
将数组中 $3^2$ 及以上的所有 3 的倍数位置的元素设为 false
对于第 4 个、第 5 个、……、第 N 个元素，重复相同的处理

※ 之所以将平方以上的元素作为 false 的目标，是因为小于平方的数已经被处理过（列举已完成）。

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

稍微优化的版本

考虑到以下几点，我们进行稍微优化后的实现：

数组不使用 true 而是使用 false 进行初始化（这样更快）
2 的倍数不是素数，所以省略将 2 的倍数元素设为 false 的处理
不需要循环到 n，只需列举到 n 的平方根即可找出 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);
 }
}

参考

埃拉托斯特尼筛法

在 Rust 中枚举素数

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

我尝试写了一个在 Rust 中枚举素数的程序。

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