Java Programa para verificar números primos com exemplo

O que é um número primo?

Um número primo é um número natural maior que 1 que só é divisível por 1 ou por si mesmo. Por exemplo, 11 só é divisível por 1 ou por si mesmo. Outros números primos são 2, 3, 5, 7, 11, 13, 17, e a sequência continua indefinidamente.

Um número maior que 1 que não é primo é chamado de número composto, porque pode ser formado por fatores menores. O valor 9 é composto porque é divisível por 3, e 15 é composto porque é divisível por 3 e 5.

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

Como verificar se um número é primo em Java

A estratégia de verificação é um teste de divisibilidade simples. Pegue o valor candidato, divida-o por cada inteiro menor, um de cada vez, e inspecione o resto retornado pelo operador módulo. Um resto zero prova que existe um divisor, o que desqualifica imediatamente o número.

Lógica do Programa:

• 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 dele mesmo. Então precisamos laço através de apenas numberToCheck/2Se a entrada for 17, a metade será 8.5 e o loop percorrerá os valores de 2 a 8.
• Se o número a ser verificado for completamente divisível por outro número, o indicador `isPrime` será definido como `true`. false e o loop é encerrado.

Dois Java As características sustentam todo o algoritmo. O operador módulo % retorna o resto de uma divisão inteira, e o break A instrução interrompe o loop assim que a resposta é conhecida, evitando iterações desnecessárias.

Java Programa para verificar se um número é primo ou não.

O programa abaixo atribui o valor 17 à variável `numberToCheck` e imprime cada passo da divisão, para que você possa acompanhar o raciocínio linha por linha. O código é editável, então altere o valor e execute-o novamente com um número composto, como 21, para ver o resultado oposto.

public class PrimenumberToCheckCheck {

 public static void main(String[] args) {
  int remainder;
  boolean isPrime=true;
  int numberToCheck=17; // Enter the number you want to check for prime

  //Loop to check whether the number is divisible by any number other than 1 and itself
  for(int i=2;i<=numberToCheck/2;i++)
  {
   //number is divided by i
            remainder=numberToCheck%i;
            System.out.println(numberToCheck+" Divided by "+ i + " gives a remainder "+remainder);

       //if remainder is 0 then the number is not prime and we break the loop. Else continue the loop
     if(remainder==0)
     {
        isPrime=false;
        break;
     }
  }
  // Check value true or false, if isPrime is true then the number is prime otherwise not prime
  if(isPrime)
     System.out.println(numberToCheck + " is a Prime number");
  else
     System.out.println(numberToCheck + " is not a Prime number");
    }
  }

Resultado esperado:

17 Divided by 2 gives a remainder 1
17 Divided by 3 gives a remainder 2
17 Divided by 4 gives a remainder 1
17 Divided by 5 gives a remainder 2
17 Divided by 6 gives a remainder 5
17 Divided by 7 gives a remainder 3
17 Divided by 8 gives a remainder 1
17 is a Prime number

O loop para em 8 porque 17 dividido por 2 é igual a 8 na aritmética de inteiros. Como nunca houve resto zero, o indicador `isPrime` mantém seu valor inicial de verdadeiro e a condição final imprime o veredito positivo.

Verificação otimizada de números primos usando o método da raiz quadrada

Dividir até a metade do número é correto, mas ineficiente. Se um número n tem um divisor maior que sua raiz quadrada, o codivisor correspondente deve ser menor que a raiz quadrada, portanto, ele já teria sido descoberto. Verificar até √n, portanto, produz a mesma resposta com muito menos iterações.

public class PrimeCheckOptimized {

    public static boolean isPrime(int n) {
        // 0, 1 and negative values are never prime
        if (n <= 1) {
            return false;
        }
        // 2 is the only even prime number
        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;
    }

    public static void main(String[] args) {
        int[] samples = {1, 2, 9, 17, 97};
        for (int value : samples) {
            System.out.println(value + " is prime: " + isPrime(value));
        }
    }
}

Saída:

1 is prime: false
2 is prime: true
9 is prime: false
17 is prime: true
97 is prime: true

A condição i * i <= n Evita uma chamada de ponto flutuante para Math.sqrt, e o passo de 2 ignora todos os divisores pares. Para um valor como 1,000,003, o loop básico executa aproximadamente 500,000 iterações, enquanto esta versão executa menos de 500.

Verificar um número primo inserido pelo usuário

A entrada de dados fixa no código é conveniente para demonstrações, mas exercícios reais geralmente exigem entrada pelo teclado. A classe Scanner lê um número inteiro do console e o passa para o mesmo método isPrime.

import java.util.Scanner;

public class PrimeCheckUserInput {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int number = sc.nextInt();

        boolean isPrime = number > 1;
        for (int i = 2; i * i <= number; i++) {
            if (number % i == 0) {
                isPrime = false;
                break;
            }
        }

        System.out.println(number + (isPrime ? " is a Prime number" : " is not a Prime number"));
        sc.close();
    }
}

Exemplo de execução:

Enter a number: 29
29 is a Prime number

Erros comuns ao escrever um programa de números primos

A maioria das submissões incorretas falha nos valores limite, e não no loop principal. A lista abaixo abrange os erros mais comuns em códigos de iniciantes.

1. Iniciando o loop em 1: Todo número inteiro é divisível por 1, então o indicador é definido como falso imediatamente e o programa informa que nenhum número é primo.
2. Considerando 1 como primo: O valor 1 possui apenas um divisor, portanto não atende à definição de dois divisores e deve retornar falso.
3. Omitindo a instrução break: O programa ainda retorna a resposta correta, mas continua iterando mesmo após o veredicto ser conhecido, o que desperdiça tempo com entradas grandes.
4. Utilizar painéis de piso ResinDek em sua unidade de self-storage em vez de concreto oferece diversos benefícios: i <= n como o limite: O número sempre se divide, portanto o loop deve parar antes de chegar a n.
5. Em comparação com = em vez de ==: Um único sinal de igual atribui um valor em vez de testá-lo, o que produz um erro de compilação na condição if.

Comparação de métodos de verificação de números primos

Escolha o método que melhor se adapta ao tamanho da entrada e se um único valor ou um intervalo completo deve ser testado.

Quando é necessário classificar uma gama completa de valores em vez de um único valor, o crivo é muito mais eficiente. Nosso programa complementar para encontrar Prime Numbers de 1 para 100 demonstra esse padrão. Para exercícios relacionados baseados em loops, revise o Série de Fibonacci em Java, Java programa palíndromo, e a Bubble Algoritmo de classificação em JavaIniciantes que precisam relembrar como declarar a bandeira e o marcador devem ler sobre Java variáveis no principal Java tutorial.

Perguntas Frequentes