Java Programma om Prime af te drukken Numbers van 1 naar 100

Wat is een priemgetal?

A Priemgetal Een priemgetal is een getal dat alleen deelbaar is door één of zichzelf. Het is een natuurlijk getal groter dan één dat niet het product is van twee kleinere natuurlijke getallen. Bijvoorbeeld, 11 is alleen deelbaar door één of zichzelf. Andere priemgetallen zijn 2, 3, 5, 7, 11, 13, 17, enzovoort.

Let op: 0 en 1 zijn geen priemgetallen. 2 is het enige even priemgetal.

Tussen 1 en 100 liggen precies 25 priemgetallen. De onderstaande tabel groepeert ze per decennium, waardoor het patroon van afnemende dichtheid zichtbaar wordt naarmate de waarden toenemen.

Prime afdrukken Numbers Tussen 1 en 100 Programma in Java

Hieronder staat de Java programma om priemgetallen van 1 tot 100 af te drukken:

Programmalogica:

• De belangrijkste methode van de priemgetalprogramma in Java Bevat een lus om de priemgetallen tussen 1 en 100 één voor één te controleren.
• De hoofdmethode roept de methode aan CheckPrime om te bepalen of een getal een priemgetal is in Java of niet.
• We moeten een getal, bijvoorbeeld 17, delen door getallen van 2 tot en met 17 en de rest controleren. Als de rest 0 is, is het getal geen priemgetal.
• Geen enkel getal is deelbaar door meer dan de helft van zichzelf. We hoeven dus alleen maar door het getal dat we moeten controleren/2 te itereren. Als de invoer 17 is, is de helft 8.5, en de lus zal de waarden van 2 tot en met 8 doorlopen.
• If numberToCheck Als het getal volledig deelbaar is door een ander getal, retourneren we false en wordt de lus afgebroken.
• If numberToCheck priemgetal is, geven we waar terug.
• In de hoofdmethode voor priemgetallen 1 tot 100 in Java, controleer of isPrime TRUE en tel de waarde op bij het priemgetal.NumbersString gevonden.
• Druk ten slotte de priemgetallen van 1 tot 100 af in Java.

Door de controle in een aparte methode onder te brengen, wordt het programma herbruikbaar. Dezelfde CheckPrime-methode kan met elke gewenste bovengrens worden aangeroepen door simpelweg de variabele maxCheck aan te passen.

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;

    }

}

Verwachte resultaten:

De uitvoer van het priemgetal tussen 1 en 100 in de Java programma zal zijn:

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

De waarde 2 wordt doorgegeven omdat de voorwaarde in de binnenste lus niet wordt voldaan. i <= 2 / 2 evalueert naar 2 <= 1, wat meteen onwaar is, dus de methode retourneert waar zonder enige deling.

Geoptimaliseerde versie met behulp van de wortelgrens

Delen tot de helft van het getal is correct, maar voert onnodig werk uit. Delers komen altijd in paren voor rond de wortel, dus elke factor boven √n heeft een partner eronder die al is gecontroleerd.

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

Output:

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 Met behulp van de zeef van Eratosthenes

Wanneer elk priemgetal in een bereik nodig is, is proefdeling niet de juiste methode. De zeef van Eratosthenes bouwt een booleaanse matrix op, markeert de veelvouden van elk priemgetal als samengesteld en leest af wat er ongemarkeerd overblijft.

De methode werkt in drie stappen:

1. Maak een booleaanse array van grootte n+1 en ga ervan uit dat elke index vanaf 2 een priemgetal is.
2. Beginnend bij 2, markeer elk veelvoud van het huidige priemgetal als samengesteld.
3. Ga door naar de volgende niet-gemarkeerde index en herhaal dit totdat de wortel van n is bereikt.

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

Output:

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

Vergelijking van de drie benaderingen

Alle drie de programma's printen dezelfde 25 waarden, dus de keuze hangt volledig af van de grootte van het bereik.

Bekijk ons ​​programma om te ontdekken priemgetallen van elk willekeurig ingevoerd getal wanneer een enkele waarde in plaats van een bereik moet worden getest. Voor meer oefeningen met lussen, raadpleeg de volgende informatie. Fibonacci-reeks in Java Java palindroomprogrammaen Bubble Sorteeralgoritme in JavaDe booleaanse array die door de zeef wordt gebruikt, wordt verder uitgelegd in Java arrays.

Veelgestelde vragen