Programme de nombre parfait en Java
Dans cet article, nous développerons un programme Java pour vérifier que le nombre est un nombre parfait ou non. Nous essaierons de développer une méthode qui donnera de hautes performances, et nous développerons également un programme Java pour trouver tous les nombres parfaits qui appartiennent à une plage donnée.
Numéro parfait :- Un nombre dont la somme des facteurs sauf lui-même est égal au même nombre est appelé un nombre parfait.
Exemple :- 6
Les facteurs de 6 (sauf lui-même) sont 1,2,3.
La somme de ces facteurs 1+2+3 =6 Donc, 6 est un nombre parfait.
Un autre exemple :- 28
Les facteurs de 28 (sauf lui-même) sont 1, 2, 4, 7, 14
La somme des facteurs de 28 =1+2+4+7+14 =28
D'où 28 est aussi un nombre parfait.
Logique pour vérifier le nombre parfait en Java
1) Prendre un nombre
2) Prendre une variable sum_of_factors et l'initialiser avec 0
3) trouver les facteurs du nombre (sauf lui-même)
4) Ajouter les facteurs dans la variable sum_of_factors
5) Si sum_of_factors est égal à l'entrée (nombre) alors c'est un nombre parfait
Code Java pour le nombre parfait
Nous devons trouver le facteur sauf pour lui-même, il est donc préférable d'itérer la boucle uniquement pour nombre/2 fois, car si nous excluons le nombre, tous les facteurs du nombre seront inférieurs ou égaux à la moitié du nombre . Par exemple :- Sauf lui-même, les facteurs de 10 sont 1, 2 et 5. Ceux-ci sont tous inférieurs ou égaux à la moitié du nombre 10, c'est-à-dire 10/2=5
// Check the number is perfect number or not
public static boolean isPerfect(int number) {
// declare variables
int sum_of_factors = 0;
// find factors of the number
for(int i=1; i<= number/2; i++)
if(number%i == 0)
// add factor in sum_of_factors
sum_of_factors += i;
// compare sum_of_factors and number
if (sum_of_factors == number)
return true; // perfect number
return false; // not a perfect number
}Voir également :- Numéro spécial, Numéro magique, Numéro Armstrong, Numéro parfait, Numéro maléfique, Numéro espion, Numéro ensoleillé en Java
Programme Java pour vérifier le nombre parfait
Sur la base de la méthode ci-dessus, nous pouvons écrire un programme Java pour vérifier que le nombre donné est un nombre parfait ou non.
import java.util.Scanner;
public class PerfectNumber {
// Check the number is perfect number or not
public static boolean isPerfect(int number) {
// declare variables
int sum_of_factors = 0;
// find factors of the number
for(int i=1; i<= number/2; i++)
if(number%i == 0)
// add factor in sum_of_factors
sum_of_factors += i;
// compare sum_of_factors and number
if (sum_of_factors == number)
return true; // perfect number
return false; // not a perfect number
}
public static void main(String[] args) {
// declare variables
int number = 0;
boolean result = false;
//create Scanner class object to take input
Scanner scan = new Scanner(System.in);
// take input from end-user
System.out.print("Enter an integer number:: ");
number = scan.nextInt();
// check number is perfect number or not
result = isPerfect(number);
if(result)
System.out.println(number +
" is a perfect number.");
else
System.out.println(number +
" is not a perfect number");
// close Scanner class object
scan.close();
}
}La sortie des différents cas de test :-
Entrez un nombre entier ::6
6 est un nombre parfait.
Entrez un nombre entier ::12
12 n'est pas un nombre parfait
Entrez un nombre entier ::28
28 est un nombre parfait.
Optimisation
Ce programme dépend entièrement de trouver des facteurs du nombre. Nous devrions écrire un tel code qui trouve des facteurs (sauf lui-même) et donne de meilleures performances pour trouver les facteurs.
Dans le post précédent trouver les facteurs d'un nombre, nous avons expliqué comment écrire une méthode pour trouver rapidement les facteurs d'un nombre et donner de meilleures performances. Dans la méthode ci-dessous, nous l'avons utilisé.
// check the number is perfect number or not
public static boolean isPerfect(int num) {
// declare variables
int sum_of_factors = 0;
// find factors of the number
for(int i=1; i<= Math.sqrt(num); i++) {
// if number is divisible by i
if(num % i == 0) {
sum_of_factors += i;
// don't add number itself
// and sqrt(num) second times
if( (i != 1) && ((num/i) != Math.sqrt(num)) ){
// add factor in sum_of_factors
sum_of_factors += (num/i);
}
}
}
// compare sum_of_factors and number
return (sum_of_factors == num);
}
Pour vérifier le nombre parfait, nous ne devons pas ajouter le nombre lui-même, donc la méthode ci-dessus n'ajoute pas de valeur (num/i) lorsque le nombre i==1 car num/i donnera num c'est-à-dire num/1 =num
De même, nous ne devrions pas ajouter la valeur sqrt(num) pour la deuxième fois. Si le sqrt(num) est le facteur du nombre alors il sera ajouté à sum_of_digits car num%i ==0. Mais le num/i donnera également le même nombre, et il devrait être ajouté dans le sum_of_factors. Par conséquent, nous avions écrit la condition comme,
/* Except number itself
* and sqrt(num) add remaining factors
* which is greater than sqrt(num)
*/
if( (i != 1) && ((num/i) != Math.sqrt(num)) ){
// add factor in sum_of_factors
sum_of_factors += (num/i);
}Nous utiliserons cette solution optimisée pour trouver le nombre parfait dans une plage donnée.
Programme Java pour trouver le nombre parfait dans une plage
En utilisant des boucles, nous pouvons trouver tous les nombres parfaits qui appartiennent à une plage donnée.
import java.util.Scanner;
public class PerfectNumberInRange {
// Check the number is perfect number or not
public static boolean isPerfect(int num) {
// declare variables
int sum_of_factors = 0;
// find factors of the number
for(int i=1; i<= Math.sqrt(num); i++) {
if(num % i == 0) {
sum_of_factors += i;
// don't add number itself
// and sqrt(num) second times
if( (i != 1) && ((num/i) != Math.sqrt(num)) ){
// add remaining factors
sum_of_factors += (num/i);
}
}
}
// compare sum_of_factors and number
return (sum_of_factors == num);
}
public static void main(String[] args) {
// declare variables
int minRange = 0, maxRange = 0;
// create Scanner class object & read inputs
Scanner scan = new Scanner(System.in);
System.out.print("Enter min value of range:: ");
minRange = scan.nextInt();
System.out.print("Enter max value of range:: ");
maxRange = scan.nextInt();
// check number
System.out.println("The perfect numbers from "+
minRange+" to "+ maxRange+" are:: ");
for(int i=minRange; i<=maxRange; i++) {
if(isPerfect(i))
System.out.print(i+" ");
}
// close Scanner class object
scan.close();
}
}Sortie pour les différents cas de test :-
Entrer la valeur min de la plage ::0
Entrer la valeur max de la plage ::100
Les nombres parfaits de 0 à 100 sont ::0 1 6 28
Entrez la valeur minimale de la plage : 1
Entrez la valeur maximale de la plage : 1000
Les nombres parfaits de 1 à 1000 sont : :1 6 28 496
Entrez la valeur minimale de la plage : 100
Entrez la valeur maximale de la plage : 1000000
Les nombres parfaits entre 100 et 1000000 sont : :496 8128
