Números Primos on kenji.blog

Código C para gerar números primos

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

Abaixo está um código C simples que gera números primos dentro de um intervalo especificado. Neste exemplo, enumeramos números primos de 1 a 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("Digite o valor máximo do intervalo para gerar números primos: ");
 scanf("%d", &n);
 printf("Os números primos de 1 a %d são:\n", n);
 printPrimes(n);
 return 0;
}

Este código funciona da seguinte forma:

Função isPrime: Determina se um determinado número é primo. Por uma questão de eficiência, primeiro verifica-se se é divisível por 2 e 3 e, em seguida, prossegue verificando em múltiplos de 6.
Função printPrimes: Gera números primos dentro de um intervalo especificado. O 2 é impresso primeiro e, em seguida, apenas os números ímpares são verificados.
Função main: Solicita que o usuário insira o valor máximo do intervalo e imprime os números primos dentro desse intervalo.

Se você compilar e executar este código, os números primos dentro do intervalo especificado serão exibidos.

Como listar números primos menores que 1000 usando o Crivo de Eratóstenes

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

O que é o Crivo de Eratóstenes?

O Crivo de Eratóstenes é um algoritmo para encontrar todos os números primos até um determinado limite. O algoritmo é simples e pode ser implementado através das seguintes etapas:

Crie um array booleano com N elementos e inicialize todos os elementos como verdadeiros (true).
Defina os elementos nas posições 0 e 1 do array como falsos (pois 0 e 1 não são números primos).
Se o 2º elemento do array for verdadeiro, imprima 2 como número primo.
Defina todos os múltiplos de 2 a partir de $2^2$ como falsos (*).
Se o 3º elemento do array for verdadeiro, imprima 3 como número primo.
Defina todos os múltiplos de 3 a partir de $3^2$ como falsos.
Repita o mesmo processo para o 4º, 5º, …, e N-ésimo elementos.

O motivo de começar a definir como falsos os múltiplos a partir do quadrado (ex: $2^2$) é que os números menores que o quadrado já foram processados (já foram marcados ou listados).

Implementação em 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;
 }
 }
 }
}

Versão levemente otimizada

Podemos otimizar um pouco a implementação considerando os seguintes pontos:

Inicializar o array com falso (false) em vez de verdadeiro (true) (isso é mais rápido).
Uma vez que múltiplos de 2 não são números primos, pule o processo de definir múltiplos de 2 como falso.
Não é necessário iterar até n; listar os números primos até a raiz quadrada de n é suficiente para encontrar todos os primos menores ou iguais a 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);
 }
}

Referência

Crivo de Eratóstenes (Wikipedia)

Enumerando Números Primos em Rust

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

Escrevi um programa para enumerar números primos em 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);
 }
}