Nombres premiers en Java

Cet article concerne les nombres premiers en Java. Un nombre premier est une sorte de nombre qui n'est divisible que par l'unité et le nombre lui-même. Il n'est divisible par aucun autre nombre. Les nombres premiers sont des types particuliers de nombres. L'exception des nombres est 1 et 2. 1 est le seul nombre qui n'est ni premier ni composé. 2 est le seul nombre premier pair dans la nature. Le contraire des nombres premiers sont les nombres divisibles par des nombres autres que le nombre lui-même ainsi que l'unité. Les nombres composés et les nombres premiers sont opposés. Généralement, les nombres premiers sont des nombres impairs à l'exception du nombre 2. Cela ne signifie pas nécessairement qu'un nombre impair est toujours un nombre premier car il peut être divisible par 3 et par tout autre nombre impair.

Exemples de nombres premiers en Java

Vous trouverez ci-dessous des exemples d'implémentation de nombres premiers en Java :

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Exemple n°1 – Utilisation de la boucle For

Dans le premier exemple de codage, nous allons vérifier si un nombre est premier ou non. Nous saisissons d’abord le numéro à l’aide de l’entrée Buffered Reader Stream. Ensuite nous avons une boucle for dans laquelle nous allons vérifier la divisibilité du nombre par n'importe quel autre nombre sauf 1 et tout autre nombre. La boucle for commence à partir de 2, puis continue jusqu'à la moitié du nombre respectif. Ensuite, nous avons une variable qui indique si le nombre est divisible ou non par n'importe quel nombre, qui fait partie de la boucle. Le code et la partie de la boucle sont présentés ci-dessous, qui entre un nombre et donne la sortie respective si ce nombre est un nombre premier ou non. Dans le programme, le java.io.* est importé afin qu'il y ait des opérations d'entrée/sortie apparaissant dans les lignes de code suivantes. De plus, s’il existe une IOException, elle est traitée différemment. Nous avons donné la commande throws IO Exception après la déclaration de main, qui lève une exception qui se produit pendant l'opération d'entrée/sortie. En dehors de cela, il existe des noms significatifs utilisés dans le programme pour que toute personne lisant le programme puisse les comprendre.

Code :

import java.io.*;
public class Prime
{
public static void main(String[] args) throws IOException
{
BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
System.out.println("ENTER A NUMBER TO CHECK IF IT IS PRIME OR NOT");
int num= Integer.parseInt(br.readLine());
boolean count = false;
for(int i = 2; i <= num/2; ++i)
{
// condition for nonprime number
if(num % i == 0)
{
count = true;
break;
}
}
if (!count)
System.out.println(num + " is a prime number.");
else
System.out.println(num + " is not a prime number.");
}
}

Sortie :

Explication du code : Dans la sortie, nous voyons si un nombre saisi est premier ou non. Tout d’abord, nous saisissons 29 comme nombre pour vérifier s’il est premier ou non. Nous découvrons que 29 est un nombre premier car il n'est divisible que par le nombre unité et par le nombre lui-même. Hormis cela, il n'est divisible par aucun autre nombre.

Deuxièmement, nous entrons un autre nombre pour vérifier si le nombre est premier ou non. Nous entrons 58 comme nombre, puis nous vérifions si le nombre est premier ou non. Enfin, on découvre que 58 n’est pas un nombre premier, mais c’est un nombre composé. C'est un nombre pair divisible par 2, 29 autre que l'unité et le nombre lui-même.

Exemple n°2 – Utilisation de la boucle While

Dans l'exemple de codage, nous allons voir l'utilisation de la boucle While pour vérifier si un nombre est premier ou non. Nous utilisons la même logique que la boucle for, mais nous avons une vision différente du programme.

Code :

import java.io.*;
public class PrimeNumber
{
public static void main(String[] args)throws IOException
{
BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
System.out.println("ENTER A NUMBER TO CHECK IF IT IS PRIME OR NOT");
int num= Integer.parseInt(br.readLine());
int i = 2;
boolean count = false;
while(i <= num/2)
{
// condition for nonprime number
if(num % i == 0)
{
count = true;
break;
}
++i;
}
if (!count)
System.out.println(num + " is a prime number.");
else
System.out.println(num + " is not a prime number.");
}
}

Sortie :

Explication du code : Dans l'exemple de sortie, nous saisissons deux nombres impairs pour vérifier si les nombres sont premiers ou non. Nous saisissons 71 et 37 comme deux nombres et découvrons finalement que les deux nombres sont des nombres premiers car ils ne sont divisibles que par 1 et par le nombre lui-même.

Exemple n°3 – Utilisation du nombre

Dans cet exemple de codage, nous allons vérifier les nombres premiers dans une plage de nombres. Nous entrons un nombre minimum de 20 et un nombre maximum de 50, puis nous trouvons les nombres premiers dans cette plage. C'est un programme très simple, et simplement en changeant les variables min et max, nous pouvons trouver les nombres premiers entre les variables min et max. L'exemple de codage est présenté ci-dessous.

Code :

import java.io.*;
public class PrimeRange
{
public static void main(String[] args)
{
int min = 20, max = 50;
while (min < max) {
boolean count = false;
for(int i = 2; i <= min/2; ++i) {
// condition for nonprime number
if(min % i == 0) {
count = true;
break;
}
}
if (!count)
System.out.print(min + " ");
++min;
}
}
}

Sortie :

Explication du code : Dans le code ci-dessus, on trouve le nombre de nombres premiers entre 20 et 50. On trouve les nombres qui ne sont divisibles que par l'unité et le nombre lui-même. Les nombres premiers sont 23, 29, 31, 37, 41, 43 et 47. Le code utilise une seule boucle for, qui est utilisée pour vérifier la divisibilité du nombre par la variable de contrôle de boucle for respective. Si le nombre est divisible, c'est un nombre composé, et si le nombre n'est pas divisible, c'est un nombre premier.

Conclusion

Dans cet article, nous voyons les nombres premiers fonctionner en utilisant une boucle for et une boucle while. Nous voyons également les nombres premiers présents dans une certaine plage. La logique utilisée pour vérifier un nombre premier à l’aide d’une boucle for et d’une boucle while est presque la même. La vérification des nombres premiers est donc assez simple. La variable de contrôle de boucle est un facteur très important pour vérifier si un nombre est premier ou non.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!