Java Programme d'impression Prime Numbers à partir de 1 100

Qu'est-ce qu'un nombre premier?

A Nombre premier Un nombre premier est un nombre qui n'est divisible que par un ou par lui-même. C'est un nombre naturel supérieur à un qui n'est pas le produit de deux nombres naturels inférieurs. Par exemple, 11 n'est divisible que par un ou par lui-même. Parmi les autres nombres premiers, on trouve : 2, 3, 5, 7, 11, 13, 17, etc.

À noter: 0 et 1 ne sont pas des nombres premiers. 2 est le seul nombre premier pair.

Entre 1 et 100, il existe exactement 25 nombres premiers. Le tableau ci-dessous les regroupe par décennie, ce qui met en évidence la diminution progressive de leur nombre à mesure que les valeurs augmentent.

Comment imprimer Prime Numbers Entre 1 et 100 Programme en Java

Voici le Java programme pour imprimer les nombres premiers de 1 à 100 :

Logique du programme :

• La principale méthode de programme de nombres premiers dans Java contient une boucle pour vérifier les nombres premiers entre 1 et 100 un par un.
• La méthode principale appelle la méthode CheckPrime pour déterminer si un nombre est un nombre premier dans Java ou non.
• Il faut diviser un nombre donné, par exemple 17, par les nombres compris entre 2 et 17 et vérifier le reste. Si le reste est 0, le nombre n'est pas premier.
• Aucun nombre n'est divisible par plus de sa moitié. Il suffit donc de parcourir la moitié du nombre à vérifier. Si la valeur saisie est 17, sa moitié est 8.5, et la boucle parcourra les valeurs de 2 à 8.
• If numberToCheck Si le nombre est entièrement divisible par un autre nombre, on renvoie faux et la boucle est interrompue.
• If numberToCheck est premier, nous retournons vrai.
• Dans la méthode principale pour les nombres premiers de 1 à 100 dans Java, vérifiez si isPrime est TRUE et ajoutez la valeur au nombre premierNumbersChaîne trouvée.
• Enfin, imprimez les nombres premiers de 1 à 100 dans Java.

Le fait de séparer la vérification dans une méthode dédiée rend le programme réutilisable. La même méthode CheckPrime peut être appelée avec n'importe quelle limite supérieure en modifiant simplement la variable 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;

    }

}

Production attendue:

Le résultat du nombre premier compris entre 1 et 100 dans le Java programme seront:

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

La valeur 2 est transmise car la condition de la boucle interne est remplie. i <= 2 / 2 évalue à 2 <= 1, ce qui est faux d'emblée, donc la méthode renvoie vrai sans une seule division.

Version optimisée utilisant la borne de la racine carrée

Diviser jusqu'à la moitié du nombre est correct, mais cela représente un travail inutile. Les diviseurs apparaissent toujours par paires autour de la racine carrée ; par conséquent, tout facteur supérieur à √n a un homologue inférieur qui a déjà été testé.

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

Sortie :

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

Imprimer Prime Numbers Utilisation du crible d'Ératosthène

Lorsque tous les nombres premiers d'un intervalle sont nécessaires, la division par essais successifs est inadaptée. Le crible d'Ératosthène construit un tableau booléen, marque les multiples de chaque nombre premier comme composés et lit les éléments non marqués.

La méthode fonctionne en trois étapes :

1. Créez un tableau booléen de taille n+1 et supposez que chaque indice à partir de 2 est premier.
2. En commençant par 2, marquez chaque multiple du nombre premier actuel comme composé.
3. Passez à l'indice non marqué suivant et répétez jusqu'à ce que la racine carrée de n soit dépassée.

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

Sortie :

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

Comparaison des trois approches

Les trois programmes affichent les mêmes 25 valeurs, le choix dépend donc entièrement de la taille de la plage.

Consultez notre programme pour trouver nombres premiers à partir de n'importe quel nombre d'entrée lorsqu'il faut tester une valeur unique plutôt qu'une plage de valeurs. Pour d'autres exercices basés sur des boucles, consultez la section correspondante. la série de Fibonacci dans Java, le Java programme palindromeainsi que, Bubble Algorithme de tri dans JavaLe tableau booléen utilisé par le crible est expliqué plus en détail dans Java tableaux.

FAQ