Java Programa para Imprimir Prime Numbers de 1 para 100

O que é um número primo?

A Número primo Um número primo é divisível apenas por um ou por si mesmo. É um número natural maior que um que não é produto de dois números naturais menores. Por exemplo, 11 é divisível apenas por um ou por si mesmo. Outros números primos são 2, 3, 5, 7, 11, 13, 17 e assim por diante.

Observação: 0 e 1 não são números primos. 2 é o único número primo par.

Entre 1 e 100, existem exatamente 25 números primos. A tabela abaixo os agrupa por década, o que torna visível o padrão de rarefação à medida que os valores aumentam.

Como imprimir Prime Numbers Entre 1 a 100 Programa em Java

Abaixo está o Java programa para imprimir números primos de 1 a 100:

Lógica do Programa:

• O principal método do programa de números primos em Java Contém um loop para verificar números primos entre 1 e 100, um por um.
• O método principal chama o método CheckPrime para determinar se um número é primo em Java ou não.
• Precisamos dividir um número de entrada, digamos 17, pelos valores de 2 a 17 e verificar o resto. Se o resto for 0, o número não é primo.
• Nenhum número é divisível por mais da metade de si mesmo. Portanto, precisamos percorrer apenas o número_para_verificar dividido por 2. Se a entrada for 17, a metade é 8.5, e o loop iterará pelos valores de 2 a 8.
• If numberToCheck Se um número for inteiramente divisível por outro, retornamos falso e o loop é interrompido.
• If numberToCheck é primo, retornamos verdadeiro.
• No método principal para números primos de 1 a 100 em Java, verifique se isPrime é TRUE e adicione o valor ao número primo.NumbersString encontrada.
• Por fim, imprima números primos de 1 a 100 em Java.

O que torna o programa reutilizável é a separação da verificação em um método próprio. O mesmo método `CheckPrime` pode ser chamado com qualquer limite superior, bastando alterar a variável `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;

    }

}

Resultado esperado:

A saída do número primo entre 1 e 100 no 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

O valor 2 é aprovado devido à condição do loop interno. i <= 2 / 2 avalia como 2 <= 1, que é falso imediatamente, então o método retorna verdadeiro sem nenhuma divisão.

Versão otimizada usando o limite da raiz quadrada

Dividir até a metade do número está correto, mas realiza cálculos desnecessários. Os divisores sempre ocorrem em pares ao redor da raiz quadrada, portanto, qualquer fator acima de √n tem um correspondente abaixo dele que já foi testado.

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;
    }
}

Saída:

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

Impressão Prime Numbers Usando o Crivo de Eratóstenes

Quando todos os números primos em um intervalo são necessários, a divisão por tentativa é a ferramenta errada. O Crivo de Eratóstenes constrói uma matriz booleana, marca os múltiplos de cada primo como compostos e lê o que resta sem marcação.

O método funciona em três etapas:

1. Crie um array booleano de tamanho n+1 e assuma que todos os índices a partir de 2 são primos.
2. A partir de 2, marque todos os múltiplos do número primo atual como compostos.
3. Avance para o próximo índice não marcado e repita até que a raiz quadrada de n seja ultrapassada.

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());
    }
}

Saída:

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

Comparação das três abordagens

Os três programas imprimem os mesmos 25 valores, portanto a escolha depende inteiramente do tamanho do intervalo.

Confira nossa programação para descobrir. números primos a partir de qualquer número de entrada quando um único valor, em vez de um intervalo, precisa ser testado. Para mais exercícios com loops, consulte o Série de Fibonacci em Java, Java programa palíndromo, e a Bubble Algoritmo de classificação em JavaO array booleano usado pela peneira é explicado mais detalhadamente em Java matrizes.

Perguntas Frequentes