Java Program för att skriva ut Prime Numbers från 1 till 100

Vad är ett primtal?

A Primtal är ett tal som endast är delbart med ett eller sig självt. Det är ett naturligt tal större än ett som inte är en produkt av två mindre naturliga tal. Till exempel är 11 endast delbart med ett eller sig självt. Andra primtal är 2, 3, 5, 7, 11, 13, 17, och så vidare.

Obs: 0 och 1 är inte primtal. 2 är det enda jämna primtalet.

Mellan 1 och 100 finns exakt 25 primtal. Rutnätet nedan grupperar dem efter dekade, vilket gör det tunna mönstret synligt allt eftersom värdena växer.

Hur man skriver ut Prime Numbers Mellan 1 till 100 Program in Java

Nedan är Java program för att skriva ut primtal från 1 till 100:

Programlogik:

• Den huvudsakliga metoden för primtalsprogram i Java innehåller en loop för att kontrollera primtal mellan 1 och 100 ett i taget.
• Huvudmetoden kallar metoden CheckPrime att avgöra om ett tal är ett primtal i Java eller inte.
• Vi behöver dividera ett inmatat tal, säg 17, från värden 2 till 17 och kontrollera resten. Om resten är 0 är talet inte primtal.
• Inget tal är delbart med mer än hälften av sig självt. Så vi behöver loopa igenom bara numberToCheck/2. Om inmatningen är 17, är hälften 8.5, och loopen kommer att iterera genom värdena 2 till 8.
• If numberToCheck är helt delbar med ett annat tal, returnerar vi falskt och loopen bryts.
• If numberToCheck är prime, återkommer vi sant.
• I huvudmetoden för primtal 1 till 100 tum Java, kontrollera om isPrime är TRUE och lägg till värdet till primtaletNumbersHittade strängen.
• Skriv slutligen ut primtal från 1 till 100 tum Java.

Att separera kontrollen i en egen metod gör programmet återanvändbart. Samma CheckPrime-metod kan anropas med vilken övre gräns som helst genom att helt enkelt ändra variabeln 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;

    }

}

Förväntad produktion:

Utdata från primtalet mellan 1 och 100 i Java program kommer vara:

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

Värdet 2 godkänns eftersom det inre loopvillkoret i <= 2 / 2 utvärderar till 2 <= 1, vilket är falskt direkt, så metoden returnerar sant utan en enda division.

Optimerad version med kvadratrotsgränsen

Att dividera upp till hälften av talet är korrekt men utför onödigt arbete. Divisorer förekommer alltid i par runt kvadratroten, så alla faktorer över √n har en partner under sig som redan har testats.

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

Produktion:

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

Skriv ut Prime Numbers Använda Eratosthenes sikt

När varje primtal i ett intervall behövs är division med försöksfunktion fel verktyg. Eratosthenes såll bygger en boolesk array, markerar multiplarna av varje primtal som sammansatt och läser av det som förblir omärkt.

Metoden fungerar i tre steg:

1. Skapa en boolesk array av storleken n+1 och anta att varje index från 2 och uppåt är primtal.
2. Börja vid 2, markera varje multipel av det aktuella primtalet som sammansatt.
3. Gå vidare till nästa omarkerade index och upprepa tills kvadratroten ur n har passerats.

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

Produktion:

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

Jämförelse av de tre metoderna

Alla tre programmen skriver ut samma 25 värden, så valet beror helt på storleken på intervallet.

Kolla in vårt program för att hitta primtal från valfritt inmatningstal när ett enda värde snarare än ett intervall måste testas. För ytterligare loopdrivna övningar, gå igenom Fibonacci-serien i Java, den Java palindromprogram, Och den Bubble Sortera algoritm i JavaDen booleska arrayen som används av sikten förklaras vidare i Java arrayer.

Vanliga frågor