Números Primos on kenji.blog

Código en C para generar números primos

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

A continuación, se muestra un código en C simple que genera números primos dentro de un rango especificado. En este ejemplo, se enumeran los números primos del 1 al 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("Ingrese el valor maximo del rango para generar numeros primos: ");
 scanf("%d", &n);
 printf("Los numeros primos de 1 a %d son los siguientes:\n", n);
 printPrimes(n);
 return 0;
}

Este código funciona de la siguiente manera:

Función isPrime: Determina si un número dado es primo. Por razones de eficiencia, primero verifica si es divisible por 2 y 3, y luego procede a verificar en múltiplos de 6.
Función printPrimes: Imprime los números primos dentro del rango especificado. El 2 se imprime primero, y luego solo se verifican los números impares.
Función main: Pide al usuario que ingrese el valor máximo del rango y luego imprime los números primos dentro de ese rango.

Al compilar y ejecutar este código, se mostrarán los números primos dentro del rango especificado.

Cómo enumerar los números primos hasta 1000 usando la criba de Eratóstenes

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

¿Qué es la criba de Eratóstenes?

La criba de Eratóstenes es un algoritmo para enumerar los números primos menores o iguales a un cierto número. El algoritmo es simple y se puede implementar con los siguientes pasos:

Crear un arreglo de valores booleanos de tamaño N e inicializar todos los elementos a true.
Establecer el 0º y 1º elemento del arreglo a false (porque 0 y 1 no son primos).
Si el 2º elemento del arreglo es true, mostrar 2 como número primo.
Establecer a false todos los elementos del arreglo que sean múltiplos de 2 mayores o iguales a $2^2$*.
Si el 3º elemento del arreglo es true, mostrar 3 como número primo.
Establecer a false todos los elementos del arreglo que sean múltiplos de 3 mayores o iguales a $3^2$.
Repetir el mismo proceso para el 4º, 5º, …, N-ésimo elemento.

*Se dirigen los elementos a partir del cuadrado para convertirlos a false porque los números más pequeños que el cuadrado ya han sido procesados (su enumeración se ha completado).

Implementación 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;
 }
 }
 }
}

Una versión un poco más rápida

Realizaremos una implementación ligeramente más rápida considerando los siguientes puntos:

Inicializar el arreglo a false en lugar de true (esto es más rápido).
Omitir el proceso de establecer en false los elementos múltiplos de 2, ya que no son primos.
No es necesario iterar hasta n; si enumeramos los primos hasta la raíz cuadrada de n, podremos enumerar todos los primos menores o iguales 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);
 }
}

Referencia

Criba de Eratóstenes

'Enumerando números primos en Rust'

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

He escrito un programa para enumerar números primos en 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);
 }
}