Java Programa para imprimir Prime Numbers de 1 a 100

¿Qué es un número primo?

A Número primo Un número primo es aquel que solo es divisible por uno o por sí mismo. Es un número natural mayor que uno que no es producto de dos números naturales menores. Por ejemplo, 11 solo es divisible por uno o por sí mismo. Otros números primos son 2, 3, 5, 7, 11, 13, 17, etc.

Nota: 0 y 1 no son números primos. 2 es el único número primo par.

Entre 1 y 100 hay exactamente 25 números primos. La cuadrícula que se muestra a continuación los agrupa por décadas, lo que permite apreciar cómo disminuye el número de primos a medida que aumenta la cantidad de primos.

Cómo imprimir Prime Numbers Entre 1 y 100 Programa en Java

abajo esta el Java Programa para imprimir números primos del 1 al 100:

Lógica del programa:

• El método principal de la programa de números primos en Java Contiene un bucle para comprobar uno por uno los números primos entre 1 y 100.
• El método principal llama al método. CheckPrime para determinar si un número es un número primo en Java o no.
• Necesitamos dividir un número dado, por ejemplo 17, entre los valores del 2 al 17 y comprobar el resto. Si el resto es 0, el número no es primo.
• Ningún número es divisible por más de la mitad de sí mismo. Por lo tanto, debemos iterar sobre numberToCheck/2. Si la entrada es 17, la mitad es 8.5, y el bucle iterará sobre los valores del 2 al 8.
• If numberToCheck Si es totalmente divisible por otro número, devolvemos falso y el bucle se rompe.
• If numberToCheck es primo, devolvemos verdadero.
• En el método principal para números primos del 1 al 100 en Java, comprueba si isPrime es TRUE y sumar el valor al primoNumbersCadena encontrada.
• Por último, imprima los números primos del 1 al 100 en Java.

Separar la comprobación en un método independiente es lo que permite reutilizar el programa. El mismo método CheckPrime puede llamarse con cualquier límite superior simplemente cambiando la variable maxCheck.

public class PrimeNumbers {

    public static void main(String[] args) {

        int i;
        int num = 0;
        int maxCheck = 100; // maxCheck limit till which you want to find prime numbers
        boolean isPrime = true;

        //Empty String
        String primeNumbersFound = "";

        //Start loop 2 to maxCheck
        for (i = 2; i <= maxCheck; i++) {
            isPrime = CheckPrime(i);
            if (isPrime) {
                primeNumbersFound = primeNumbersFound + i + " ";
            }
        }
        System.out.println("Prime numbers from 1 to " + maxCheck + " are:");
        // Print prime numbers from 1 to maxCheck
        System.out.println(primeNumbersFound);
    }
    public static boolean CheckPrime(int numberToCheck) {
        int remainder;
        for (int i = 2; i <= numberToCheck / 2; i++) {
            remainder = numberToCheck % i;
            //if remainder is 0 then the number is not prime and we break the loop. Else continue the loop
            if (remainder == 0) {
                return false;
            }
        }
        return true;

    }

}

Rendimiento esperado:

La salida del número primo entre 1 y 100 en el Java programa será:

Prime numbers from 1 to 100 are:
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

El valor 2 pasa porque se cumple la condición del bucle interno. i <= 2 / 2 evalúa a 2 <= 1, lo cual es falso de inmediato, por lo que el método devuelve verdadero sin una sola división.

Versión optimizada utilizando el límite de la raíz cuadrada

Dividir hasta la mitad del número es correcto, pero implica un trabajo innecesario. Los divisores siempre aparecen en pares alrededor de la raíz cuadrada, por lo que cualquier factor mayor que √n tiene un divisor menor que ya se ha comprobado.

public class PrimeNumbersOptimized {

    public static void main(String[] args) {
        int maxCheck = 100;
        int count = 0;
        StringBuilder result = new StringBuilder();

        for (int i = 2; i <= maxCheck; i++) {
            if (isPrime(i)) {
                result.append(i).append(" ");
                count++;
            }
        }

        System.out.println("Prime numbers from 1 to " + maxCheck + " are:");
        System.out.println(result.toString().trim());
        System.out.println("Total primes found: " + count);
    }

    public static boolean isPrime(int n) {
        if (n <= 1) return false;
        if (n == 2) return true;
        if (n % 2 == 0) return false;

        // test only odd divisors up to the square root
        for (int i = 3; i * i <= n; i += 2) {
            if (n % i == 0) return false;
        }
        return true;
    }
}

Salida:

Prime numbers from 1 to 100 are:
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
Total primes found: 25

Imprimir Prime Numbers Utilizando el tamiz de Eratóstenes

Cuando se necesitan todos los números primos de un rango, la división por tanteo no es la herramienta adecuada. La criba de Eratóstenes crea una matriz booleana, marca los múltiplos de cada primo como compuestos y descarta lo que queda sin marcar.

El método funciona en tres pasos:

1. Crea una matriz booleana de tamaño n+1 y asume que cada índice a partir del 2 es primo.
2. A partir del 2, marca cada múltiplo del primo actual como compuesto.
3. Avanza al siguiente índice sin marcar y repite el proceso hasta que se haya superado la raíz cuadrada de n.

import java.util.Arrays;

public class SieveOfEratosthenes {

    public static void main(String[] args) {
        int n = 100;
        boolean[] composite = new boolean[n + 1];

        for (int p = 2; p * p <= n; p++) {
            if (!composite[p]) {
                // start at p*p because smaller multiples are already marked
                for (int multiple = p * p; multiple <= n; multiple += p) {
                    composite[multiple] = true;
                }
            }
        }

        StringBuilder result = new StringBuilder();
        for (int i = 2; i <= n; i++) {
            if (!composite[i]) {
                result.append(i).append(" ");
            }
        }

        System.out.println("Prime numbers from 1 to " + n + " are:");
        System.out.println(result.toString().trim());
    }
}

Salida:

Prime numbers from 1 to 100 are:
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

Comparación de los tres enfoques

Los tres programas imprimen los mismos 25 valores, por lo que la elección depende completamente del tamaño del rango.

Consulta nuestro programa para encontrar números primos a partir de cualquier número de entrada cuando se debe probar un solo valor en lugar de un rango. Para más ejercicios basados ​​en bucles, revise el Serie de Fibonacci en Java, Java programa de palíndromos, y Bubble Ordenar algoritmo en JavaEl array booleano utilizado por la criba se explica con más detalle en Java arrays.

Preguntas Frecuentes