Programme de nombres forts en Java
Si la somme de la factorielle des chiffres individuels d'un nombre est égale au même nombre, alors le nombre est appelé un nombre fort. Dans cet article, nous allons développer un nombre fort programme en Java.
Exemple :-
145 =1 ! + 4 ! + 5 ! =1 + 24 + 120 =145
Donc, 145 est un nombre fort.
234 =2 ! + 3 ! + 4 ! =2 + 6 + 24 =32
Donc, 234 n'est pas un nombre fort.
40585 =4 ! + 0 ! + 5 ! + 8 ! + 5 ! =24 + 1 + 120 + 40320 + 120 =40585
Donc, 40585 est un nombre fort.
Procédure pour développer une méthode pour vérifier que le nombre est un nombre fort ou non
1) Prendre un nombre en entrée
2) Prendre une variable somme et l'initialiser avec 0
3) Trouver le dernier chiffre du nombre
4) Calculer la factorielle de ce dernier chiffre
5) Ajouter le résultat factoriel dans la somme
6) supprimer le dernier chiffre du nombre
7) Répéter les étapes 3 pour 6 jusqu'à ce que le nombre devienne 0.
8) Si la somme est égale à l'entrée (nombre), alors c'est un nombre fort
La méthode Java pour vérifier que le nombre est un nombre fort ou non, peut être écrite comme ci-dessous :-
public static boolean isStrong(int number) {
// declare variables
int sum = 0, lastDigit = 0;
//store number in a temporary variable
int tempNum = number;
// traverse through all digits of number
while(tempNum != 0) {
// find last digit
lastDigit = tempNum % 10;
// calculate factorial and
// add it to the sum
sum += factorial(lastDigit);
// remove last digit
tempNum /= 10;
}
// compare sum and number
if(sum == number)
return true; // strong number
return false; // not a strong number
}Nous stockons le nombre réel dans une variable temporaire car enfin, nous devons comparer le résultat (somme) avec le nombre réel. Si le résultat (somme) est égal au nombre réel, alors le nombre est un nombre fort, sinon ce n'est pas un nombre fort.
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 un nombre fort
Maintenant, sur la base de la méthode ci-dessus, nous allons développer un programme de nombres forts dans le langage de programmation Java. Nous développerons isStrong(-) méthode pour vérifier que le nombre est un nombre fort ou non et le factorial(-) méthode pour trouver la factorielle d'un nombre.
import java.util.Scanner;
public class StrongNumber {
// Checks the number is strong number or not
public static boolean isStrong(int number) {
// declare variables
int sum = 0, lastDigit = 0;
int tempNum = number;
// traverse through all digits of number
while(tempNum != 0) {
lastDigit = tempNum % 10;
sum += factorial(lastDigit);
tempNum /= 10;
}
// compare sum and number
if(sum == number)
return true;
return false;
}
// calculate factorial of an integer
public static long factorial(int n) {
long fact = 1;
for(int i=1; i<=n; i++) {
fact *= i;
}
return fact;
}
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 strong number or not
result = isStrong(number);
if(result)
System.out.println(number +
" is a strong number.");
else
System.out.println(number +
" is not a strong number");
// close Scanner class object
scan.close();
}
}La sortie pour différents cas de test :-
Entrez un nombre entier ::145
145 est un nombre fort.
Entrez un nombre entier ::146
146 n'est pas un nombre fort
Optimisation
Nous pouvons analyser que le dernier chiffre sera toujours de 0 à 9, et à chaque fois nous devons trouver la factorielle de 0 à 9 uniquement. Il est donc préférable de calculer la valeur factorielle de 0 à 9 et de la stocker dans un tableau. Pour les grands nombres, ce sera une solution optimisée pour vérifier que le nombre est un nombre fort ou non. Conclusion :- avant de vérifier si le nombre est un nombre fort ou non, calculez la factorielle de 0 à 9 et stockez-la dans un tableau. Cela peut être fait comme ci-dessous :-
// Array to store factorial value
// from 0 to 9
static int fact[] = new int[10];
// static block to calculate factorial
static {
// factorial of 0 and 1 is 1
fact[0] = fact[1] = 1;
// factorial is also calculated as
// n! = (n-1)! * n
for(int i=2; i<fact.length; i++)
fact[i] = fact[i-1] * i;
}
Le bloc statique s'exécute avant d'exécuter la méthode main donc, les valeurs factorielles de 0 à 9 seront calculées et stockées dans le tableau fact[]. Maintenant, à l'intérieur du isStrong() méthode pour la valeur factorielle utilise ce tableau comme,
// add factorial value of last digit
// to the sum variable
sum += fact[lastDigit];Dans le programme Java ci-dessous, nous avons utilisé cette solution optimisée pour vérifier que le nombre est un nombre fort ou non.
Programme optimisé pour vérifier que le numéro est un nombre fort ou non
import java.util.Scanner;
public class StrongNumber {
// Array to store factorial value
// from 0 to 9
static int fact[] = new int[10];
// static block to calculate factorial
static {
fact[0] = fact[1] = 1;
for(int i=2; i<fact.length; ++i)
fact[i] = fact[i-1] * i;
}
// Checks the number is strong number or not
public static boolean isStrong(int number) {
// declare variables
int sum = 0, lastDigit = 0;
int tempNum = number;
// traverse through all digits of number
while(tempNum != 0) {
lastDigit = tempNum % 10;
sum += fact[lastDigit];
tempNum /= 10;
}
// compare sum and number
return (sum == number);
}
// main method
public static void main(String[] args) {
// declare variables
int number = 0;
boolean result = false;
//create Scanner class object and take input
Scanner scan = new Scanner(System.in);
System.out.print("Enter an integer number:: ");
number = scan.nextInt();
// check number is strong number or not
result = isStrong(number);
if(result)
System.out.println(number +
" is a strong number.");
else
System.out.println(number +
" is not a strong number");
// close Scanner class object
scan.close();
}
}Trouver un nombre fort en Java dans une plage donnée
Nous pouvons également trouver tous les nombres forts en Java dans une plage donnée. Pour cela, nous devons prendre l'aide de boucles. Nous prendrons des valeurs de plage comme minRange et maxRange . Plus tard, nous trouverons tous les nombres forts qui appartiennent à cette gamme.
import java.util.Scanner;
public class StorngNumberInRange {
// Array to store factorial value
// from 0 to 9
static int fact[] = new int[10];
// static block to calculate factorial
static {
fact[0] = fact[1] = 1;
for(int i=2; i<fact.length; ++i) {
fact[i] = fact[i-1] * i;
}
}
// Checks the number is strong number or not
public static boolean isStrong(int number) {
// declare variables
int sum = 0, lastDigit = 0;
int tempNum = number;
// traverse through all digits of number
while(tempNum != 0) {
lastDigit = tempNum % 10;
sum += fact[lastDigit];
tempNum /= 10;
}
// compare sum and number
return (sum == number);
}
public static void main(String[] args) {
// declare variables
int minRange = 0, maxRange = 0;
//create Scanner class object to take input
Scanner scan = new Scanner(System.in);
System.out.print("Enter the minimum value of range:: ");
minRange = scan.nextInt();
System.out.print("Enter the maximum value of range:: ");
maxRange = scan.nextInt();
// loop
System.out.println("The Strong number from "+
minRange + " to "+ maxRange+" are: ");
for(int i=minRange; i<=maxRange; i++) {
// check number
if(isStrong(i))
System.out.print(i +" ");
}
// close Scanner class object
scan.close();
}
}Sortie :-
Saisissez la valeur minimale de la plage ::1
Saisissez la valeur maximale de la plage ::1000000
Les nombres forts de 1 à 1000000 sont : 1 2 145 40585
