Java Program a Prime nyomtatásához Numbers tól 1 a 100

Mi az a prímszám?

A Prímszám olyan szám, amely csak eggyel vagy önmagával osztható. Olyan természetes szám, amely nagyobb, mint egy, és nem két kisebb természetes szám szorzata. Például a 11 csak eggyel vagy önmagával osztható. További prímszámok a 2, 3, 5, 7, 11, 13, 17 és így tovább.

Jegyzet: 0 és 1 nem prímszámok. A 2 az egyetlen páros prímszám.

1 és 100 között pontosan 25 prímszám található. Az alábbi táblázat évtizedek szerint csoportosítja őket, ami láthatóvá teszi a ritkuló mintázatot az értékek növekedésével.

Hogyan nyomtatjunk Prime Numbers 1 és 100 közötti program Java

Az alábbiakban a Java program prímszámok nyomtatására 1-től 100-ig:

Program logika:

• A fő módszer a prímszám program be Java tartalmaz egy ciklust, amely egyesével ellenőrzi az 1 és 100 közötti prímszámokat.
• A fő módszer a metódusnak nevezi CheckPrime annak megállapítására, hogy egy szám prímszám-e Java vagy sem.
• Egy bemeneti számot, mondjuk a 17-et, el kell osztanunk 2-től 17-ig terjedő értékekkel, és ellenőriznünk kell a maradékot. Ha a maradék 0, akkor a szám nem prím.
• Egyetlen szám sem osztható önmaga felénél nagyobb számmal. Tehát csak a numberToCheck/2 cikluson kell keresztülmennünk. Ha a bemenet 17, akkor a fele 8.5, és a ciklus 2-től 8-ig terjedő értékeken keresztül fog iterálni.
• If numberToCheck teljes egészében osztható egy másik számmal, akkor hamis értéket adunk vissza, és a ciklus megszakad.
• If numberToCheck elsődleges, igazat adunk vissza.
• Az 1 és 100 hüvelyk közötti prímszámok fő módszerében Java, ellenőrizd, hogy az isPrime a következő-e: TRUE és adjuk hozzá az értéket a prímszámhozNumbersTalált karakterlánc.
• Végül nyomtasson prímszámokat 1 és 100 hüvelyk között Java.

A check külön metódusba való szétválasztása teszi a programot újrafelhasználhatóvá. Ugyanaz a CheckPrime metódus bármilyen felső határértékkel meghívható egyszerűen a maxCheck változó megváltoztatásával.

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;

    }

}

Várható teljesítmény:

Az 1 és 100 közötti prímszám kimenete a Java program lesz:

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

A 2-es érték azért fogadható el, mert a belső ciklus feltétele i <= 2 / 2 -ra értékeli 2 <= 1, ami azonnal hamis, így a metódus osztás nélkül igaz értéket ad vissza.

Optimalizált verzió négyzetgyökkorlát használatával

A szám felére osztás helyes, de felesleges munkát végez. Az osztók mindig párosával fordulnak elő a négyzetgyök körül, tehát minden √n feletti tényezőnek van egy alatta lévő párja, amelyet már teszteltünk.

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 Eratoszthenész szitájának használata

Amikor egy tartomány összes prímszámára szükség van, a próbaosztás nem a megfelelő eszköz. Az Eratoszthenész-szűrő egy logikai tömböt épít, minden prímszám többszöröseit összetettként jelöli meg, és beolvassa a jelöletlen részeket.

A módszer három lépésben működik:

1. Hozz létre egy n+1 méretű logikai tömböt, és tegyük fel, hogy 2-től felfelé minden index prím.
2. 2-től kezdve jelöljük meg az aktuális prímszám minden többszörösét összetettként.
3. Lépjen a következő jelöletlen indexre, és ismételje meg a műveletet, amíg az n négyzetgyökét el nem éri.

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

A három megközelítés összehasonlítása

Mindhárom program ugyanazt a 25 értéket nyomtatja ki, így a választás teljes mértékben a tartomány méretétől függ.

Nézze meg programunkat, hogy megtalálja prímszámok bármely bemeneti számból amikor egyetlen értéket kell tesztelni egy tartomány helyett. További ciklusvezérelt gyakorlatokért tekintse át a Fibonacci-sorozat Java, a Java palindrom program, És a Bubble Rendezési algoritmus JavaA szita által használt logikai tömböt a következő részben ismertetjük részletesebben. Java tömbök.

GYIK