Java Program pentru imprimare Prime Numbers de la 1 la 100

Ce este un număr prim?

A Număr prim este un număr care este divizibil doar cu unu sau cu el însuși. Este un număr natural mai mare decât unu care nu este produsul a două numere naturale mai mici. De exemplu, 11 este divizibil doar cu unu sau cu el însuși. Alte numere prime sunt 2, 3, 5, 7, 11, 13, 17 și așa mai departe.

Notă: 0 și 1 nu sunt numere prime. 2 este singurul număr prim par.

Între 1 și 100 există exact 25 de numere prime. Grila de mai jos le grupează pe decade, ceea ce face vizibil modelul de subțiere pe măsură ce valorile cresc.

Cum se imprimă Prime Numbers Între 1 și 100 Program în Java

Mai jos este Java program pentru a imprima numere prime de la 1 la 100:

Logica programului:

• Metoda principală a program numere prime în Java conține o buclă pentru verificarea numerelor prime între 1 și 100, unul câte unul.
• Metoda principală numește metoda CheckPrime pentru a determina dacă un număr este un număr prim în Java sau nu.
• Trebuie să împărțim un număr introdus, să zicem 17, la valorile de la 2 la 17 și să verificăm restul. Dacă restul este 0, numărul nu este prim.
• Niciun număr nu este divizibil cu mai mult de jumătate din el însuși. Așadar, trebuie să parcurgem doar numberToCheck/2. Dacă intrarea este 17, jumătatea este 8.5, iar bucla va itera prin valorile de la 2 la 8.
• If numberToCheck este în întregime divizibil cu un alt număr, returnăm fals, iar bucla este întreruptă.
• If numberToCheck este prim, revenim adevărat.
• În metoda principală pentru numerele prime de la 1 la 100 in Java, verificați dacă isPrime este TRUE și adăugați valoarea la numărul primNumbersAm găsit șir de caractere.
• În cele din urmă, imprimați numere prime de la 1 la 100 in Java.

Separarea verificării într-o metodă proprie este ceea ce face ca programul să fie reutilizabil. Aceeași metodă CheckPrime poate fi apelată cu orice limită superioară pur și simplu prin modificarea variabilei 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;

    }

}

Ieșire preconizată:

Rezultatul numărului prim între 1 și 100 în Java program va fi:

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

Valoarea 2 trece deoarece condiția buclei interne i <= 2 / 2 evaluează la 2 <= 1, care este fals imediat, deci metoda returnează adevărat fără o singură diviziune.

Versiune optimizată folosind limita rădăcinii pătrate

Împărțirea la jumătate din număr este corectă, dar implică o operațiune inutilă. Divizorii apar întotdeauna în perechi în jurul rădăcinii pătrate, deci orice factor mai mare decât √n are un partener sub el, care a fost deja testat.

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

ieșire:

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 Folosind sita lui Eratostene

Când este nevoie de fiecare număr prim dintr-un interval, împărțirea prin încercări este instrumentul greșit. Sita lui Eratostene construiește o matrice booleană, marchează multiplii fiecărui număr prim ca fiind compuși și citește tot ce rămâne nemarcat.

Metoda funcționează în trei etape:

1. Creați un tablou boolean de dimensiunea n+1 și presupuneți că fiecare indice de la 2 în sus este prim.
2. Începând de la 2, marcați fiecare multiplu al numărului prim curent ca fiind compus.
3. Se avansează la următorul index nemarcat și se repetă până când se trece rădăcina pătrată a lui 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());
    }
}

ieșire:

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

Compararea celor trei abordări

Toate cele trei programe afișează aceleași 25 de valori, deci alegerea depinde în întregime de dimensiunea intervalului.

Verificați programul nostru pentru a afla numere prime din orice număr de intrare când trebuie testată o singură valoare, mai degrabă decât un interval. Pentru exerciții suplimentare bazate pe bucle, consultați Seria Fibonacci în Java, Java program palindrom, Şi Bubble Sortați algoritmul JavaTabloul boolean utilizat de sivetă este explicat mai detaliat în Java matrice.

Întrebări frecvente