Java Programma per stampare Prime Numbers da 1 a 100

Cos'è un numero primo?

A Numero primo Un numero primo è un numero divisibile solo per uno o per se stesso. È un numero naturale maggiore di uno che non è il prodotto di due numeri naturali più piccoli. Ad esempio, 11 è divisibile solo per uno o per se stesso. Altri numeri primi sono 2, 3, 5, 7, 11, 13, 17 e così via.

Nota: 0 e 1 non sono numeri primi. 2 è l’unico numero primo pari.

Tra 1 e 100 ci sono esattamente 25 numeri primi. La griglia sottostante li raggruppa per decennio, rendendo visibile la progressiva diminuzione del numero di numeri primi all'aumentare dei valori.

Come stampare Prime Numbers Tra 1 e 100 Programma in Java

Di seguito è il Java programma per stampare i numeri primi da 1 a 100:

Logica del programma:

• Il metodo principale del programma di numeri primi in Java contiene un ciclo per controllare uno per uno i numeri primi compresi tra 1 e 100.
• Il metodo main chiama il metodo CheckPrime per determinare se un numero è un numero primo in Java o non.
• Dobbiamo dividere un numero dato, ad esempio 17, per i valori compresi tra 2 e 17 e controllare il resto. Se il resto è 0, il numero non è primo.
• Nessun numero è divisibile per più della metà di se stesso. Quindi, dobbiamo iterare solo su numeroDaControllare/2. Se l'input è 17, la metà è 8.5 e il ciclo itererà sui valori da 2 a 8.
• If numberToCheck se è interamente divisibile per un altro numero, restituiamo false e il ciclo viene interrotto.
• If numberToCheck è primo, restituiamo vero.
• Nel metodo principale per i numeri primi da 1 a 100 in Java, verifica se isPrime è TRUE e aggiungere il valore al numero primoNumbersStringa trovata.
• Infine, stampa i numeri primi da 1 a 100 in Java.

Separare il controllo in un metodo a sé stante è ciò che rende il programma riutilizzabile. Lo stesso metodo CheckPrime può essere chiamato con qualsiasi limite superiore semplicemente modificando la variabile 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;

    }

}

Uscita prevista:

L'output del numero primo compreso tra 1 e 100 nel Java Programma sarà:

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

Il valore 2 passa perché la condizione del ciclo interno i <= 2 / 2 valuta a 2 <= 1, che è subito falso, quindi il metodo restituisce vero senza alcuna divisione.

Versione ottimizzata utilizzando il limite della radice quadrata

Dividere fino a metà del numero è corretto, ma esegue un lavoro non necessario. I divisori si presentano sempre a coppie attorno alla radice quadrata, quindi ogni fattore maggiore di √n ha un corrispondente minore che è già stato testato.

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

Produzione:

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

Stampa Focus Numbers Utilizzando il crivello di Eratostene

Quando è necessario individuare tutti i numeri primi di un intervallo, la divisione per tentativi non è lo strumento adatto. Il Crivello di Eratostene costruisce una matrice booleana, contrassegna i multipli di ciascun numero primo come composti e legge ciò che rimane non contrassegnato.

Il metodo si articola in tre fasi:

1. Crea un array booleano di dimensione n+1 e supponi che ogni indice da 2 in su sia primo.
2. A partire da 2, contrassegna ogni multiplo del numero primo corrente come composto.
3. Passa all'indice successivo non contrassegnato e ripeti l'operazione finché non viene superata la radice quadrata di 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());
    }
}

Produzione:

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

Confronto dei tre approcci

Tutti e tre i programmi stampano gli stessi 25 valori, quindi la scelta dipende interamente dalla dimensione dell'intervallo.

Controlla il nostro programma per trovare numeri primi da qualsiasi numero di input quando è necessario testare un singolo valore anziché un intervallo. Per ulteriori esercizi basati sui cicli, rivedere il serie di Fibonacci in Java, il Java programma palindromo Bubble Algoritmo di ordinamento in JavaL'array booleano utilizzato dal setaccio è spiegato ulteriormente in Java array.

DOMANDE FREQUENTI