Java Programm zum Drucken von Prime Numbers von 1 um 100

Was ist eine Primzahl?

A Primzahl Eine Primzahl ist eine Zahl, die nur durch eins oder sich selbst teilbar ist. Sie ist eine natürliche Zahl größer als eins, die nicht das Produkt zweier kleinerer natürlicher Zahlen ist. Beispielsweise ist 11 nur durch eins oder sich selbst teilbar. Weitere Primzahlen sind 2, 3, 5, 7, 11, 13, 17 usw.

Hinweis: 0 und 1 sind keine Primzahlen. 2 ist die einzige gerade Primzahl.

Zwischen 1 und 100 gibt es genau 25 Primzahlen. Die untenstehende Tabelle gruppiert sie nach Dekaden, wodurch das Muster der abnehmenden Anzahl mit zunehmenden Werten sichtbar wird.

So drucken Sie Prime Numbers Zwischen 1 und 100 Programm in Java

Unten ist die Java Programm zum Drucken von Primzahlen von 1 bis 100:

Programmlogik:

• Die Hauptmethode der Primzahlprogramm in Java enthält eine Schleife, um die Primzahlen zwischen 1 und 100 nacheinander zu überprüfen.
• Die Hauptmethode ruft die Methode auf CheckPrime um festzustellen, ob eine Zahl eine Primzahl ist in Java oder nicht.
• Wir müssen eine Eingabezahl, beispielsweise 17, durch die Zahlen von 2 bis 17 teilen und den Rest überprüfen. Ist der Rest 0, ist die Zahl keine Primzahl.
• Keine Zahl ist durch mehr als die Hälfte von sich selbst teilbar. Daher müssen wir nur die Zahl, die geprüft werden soll, durch 2 teilen. Wenn die Eingabe 17 ist, ist die Hälfte 8.5, und die Schleife durchläuft die Werte von 2 bis 8.
• If numberToCheck Wenn die Zahl vollständig durch eine andere Zahl teilbar ist, geben wir false zurück, und die Schleife wird abgebrochen.
• If numberToCheck prim ist, geben wir true zurück.
• In der Hauptmethode für Primzahlen 1 bis 100 in Java, prüfen Sie, ob isPrime ist TRUE und addiere den Wert zur PrimzahlNumbersGefundene Zeichenkette.
• Drucken Sie zuletzt Primzahlen von 1 bis 100 in Java.

Die Auslagerung der Überprüfung in eine eigene Methode ermöglicht die Wiederverwendbarkeit des Programms. Die Methode `CheckPrime` kann mit jedem beliebigen Obergrenzenwert aufgerufen werden, indem einfach die Variable `maxCheck` geändert wird.

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;

    }

}

Erwartete Ausgabe:

Die Ausgabe der Primzahlen zwischen 1 und 100 in der Java Programm werden:

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

Der Wert 2 wird übergeben, weil die innere Schleifenbedingung erfüllt ist. i <= 2 / 2 bewertet zu 2 <= 1Das Ergebnis ist sofort falsch, daher gibt die Methode ohne eine einzige Division true zurück.

Optimierte Version unter Verwendung der Quadratwurzelgrenze

Das Halbieren der Zahl ist zwar korrekt, führt aber zu unnötigen Rechenoperationen. Teiler treten immer paarweise um die Quadratwurzel auf, daher hat jeder Faktor oberhalb von √n einen Partner darunter, der bereits geprüft wurde.

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

Ausgang:

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

Print Prime Numbers Verwendung des Siebs des Eratosthenes

Wenn alle Primzahlen eines Bereichs benötigt werden, ist die Probedivision das falsche Verfahren. Das Sieb des Eratosthenes erstellt ein boolesches Array, markiert die Vielfachen jeder Primzahl als zusammengesetzt und liest alle übrigen, nicht markierten Zahlen aus.

Die Methode funktioniert in drei Schritten:

1. Erstelle ein boolesches Array der Größe n+1 und gehe davon aus, dass jeder Index ab 2 eine Primzahl ist.
2. Beginnend mit 2, markiere jedes Vielfache der aktuellen Primzahl als zusammengesetzte Zahl.
3. Gehe zum nächsten nicht markierten Index und wiederhole den Vorgang, bis die Quadratwurzel von n erreicht ist.

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

Ausgang:

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

Vergleich der drei Ansätze

Alle drei Programme geben dieselben 25 Werte aus, daher hängt die Wahl ausschließlich von der Größe des Wertebereichs ab.

Schauen Sie in unserem Programm nach, um herauszufinden Primzahlen aus jeder beliebigen Eingabezahl Wenn ein einzelner Wert anstelle eines Bereichs geprüft werden muss. Weitere Übungen mit Schleifen finden Sie im Abschnitt [Link einfügen]. Fibonacci-Folge in Java, hat das Java Palindromprogrammund die Bubble Sortieralgorithmus in JavaDas vom Sieb verwendete boolesche Array wird im Folgenden näher erläutert. Java Arrays.

Häufig gestellte Fragen