Encontrando el Primo Número 10,001

Los números primos han sido un tema fascinante en matemáticas desde la antigüedad. Son los bloques de construcción de los números enteros, y encontrar el primo número 10,001 es un reto interesante y educativo. En este artículo, te guiaré a través del proceso para encontrar cualquier número primo n usando varios lenguajes de programación: Python, Kotlin, Java y Go. Además, incluiremos pruebas unitarias para asegurar que nuestras soluciones son correctas.

Introducción a los Números Primos

Un número primo es un número entero mayor que 1 que solo es divisible por 1 y por sí mismo. Los primeros seis números primos son 2, 3, 5, 7, 11 y 13. Siguiendo esta lógica, el primo número 6 es 13. Nuestro objetivo es encontrar el primo número 10,001.

Estrategia para Encontrar el Primo Número 10,001

Utilizaremos el método de la criba de Eratóstenes para generar números primos y una función para obtener el enésimo número primo. La criba de Eratóstenes es un algoritmo eficiente para encontrar todos los números primos menores que un determinado entero n.

Implementaciones en Diferentes Lenguajes

Python

def criba_de_eratostenes(limite):
    primos = [True] * (limite + 1)
    p = 2
    while p**2 <= limite:
        if primos[p]:
            for i in range(p**2, limite + 1, p):
                primos[i] = False
        p += 1
    return [p for p in range(2, limite + 1) if primos[p]]

def enesimo_primo(n):
    limite = 125000  # Un límite suficientemente grande para encontrar el primo 10,001
    primos = criba_de_eratostenes(limite)
    return primos[n - 1]

# Ejemplo
print(enesimo_primo(10001))

Kotlin

fun cribaDeEratostenes(limite: Int): List<Int> {
    val primos = BooleanArray(limite + 1) { true }
    var p = 2
    while (p * p <= limite) {
        if (primos[p]) {
            for (i in p * p..limite step p) {
                primos[i] = false
            }
        }
        p++
    }
    return (2..limite).filter { primos[it] }
}

fun enesimoPrimo(n: Int): Int {
    val limite = 125000  // Un límite suficientemente grande para encontrar el primo 10,001
    val primos = cribaDeEratostenes(limite)
    return primos[n - 1]
}

// Prueba unitaria
fun main() {
    assert(enesimoPrimo(10001) == 104743)  // Verifica que el primo 10,001 es 104743
}

Java

import java.util.ArrayList;
import java.util.List;

public class PrimeNumberFinder {
    public static List<Integer> cribaDeEratostenes(int limite) {
        boolean[] primos = new boolean[limite + 1];
        for (int i = 0; i <= limite; i++) primos[i] = true;
        int p = 2;
        while (p * p <= limite) {
            if (primos[p]) {
                for (int i = p * p; i <= limite; i += p) primos[i] = false;
            }
            p++;
        }
        List<Integer> listaPrimos = new ArrayList<>();
        for (int i = 2; i <= limite; i++) {
            if (primos[i]) listaPrimos.add(i);
        }
        return listaPrimos;
    }

    public static int enesimoPrimo(int n) {
        int limite = 125000;  // Un límite suficientemente grande para encontrar el primo 10,001
        List<Integer> primos = cribaDeEratostenes(limite);
        return primos.get(n - 1);
    }

    // Prueba unitaria
    public static void main(String[] args) {
        assert enesimoPrimo(10001) == 104743 : "El primo 10,001 debe ser 104743";
    }
}

Go

package main

import (
    "fmt"
    "math"
)

// Criba de Eratóstenes para generar primos hasta un límite
func cribaDeEratostenes(limite int) []int {
    primos := make([]bool, limite+1)
    for i := 2; i <= limite; i++ {
        primos[i] = true
    }
    p := 2
    for p*p <= limite {
        if primos[p] {
            for i := p * p; i <= limite; i += p {
                primos[i] = false
            }
        }
        p++
    }
    var listaPrimos []int
    for i := 2; i <= limite; i++ {
        if primos[i] {
            listaPrimos = append(listaPrimos, i)
        }
    }
    return listaPrimos
}

// Función para encontrar el enésimo primo
func enesimoPrimo(n int) int {
    limite := 125000 // Un límite suficientemente grande para encontrar el primo 10,001
    primos := cribaDeEratostenes(limite)
    return primos[n-1]
}

// Prueba unitaria
func main() {
    resultado := enesimoPrimo(10001)
    if resultado != 104743 {
        fmt.Printf("Prueba fallida: se esperaba 104743, pero se obtuvo %d\n", resultado)
    } else {
        fmt.Println("Prueba exitosa: se obtuvo el primo número 10,001 correctamente")
    }
}

Encontrar el primo número 10,001 puede parecer una tarea desalentadora, pero con la ayuda de la criba de Eratóstenes y algunos conocimientos de programación, es bastante manejable. Hemos demostrado cómo implementar esta solución en cuatro lenguajes de programación diferentes: Python, Kotlin, Java y Go. Además, incluimos pruebas unitarias para asegurar la exactitud de nuestros programas.

Al ajustar los límites y el valor de n, puedes encontrar cualquier número primo n-ésimo que desees. ¡Feliz programación y exploración de números primos!