Простые Числа 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

Что такое решето Эратосфена

Решето Эратосфена — это алгоритм для нахождения всех простых чисел до заданного целого числа. Алгоритм прост и может быть реализован с помощью следующих шагов:

Создайте логический (bool) массив из N элементов и инициализируйте все элементы как true.
Установите 0-й и 1-й элементы массива как false (так как 0 и 1 не являются простыми числами).
Если 2-й элемент массива равен true, выведите 2 как простое число.
Установите все элементы, кратные 2, начиная с $2^2$, в false ※
Если 3-й элемент массива равен true, выведите 3 как простое число.
Установите все элементы, кратные 3, начиная с $3^2$, в 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);
 }
}