Nombre fort en Java

Un nombre fort est un nombre spécial qui peut être défini comme une addition factorielle de chaque chiffre du nombre, qui est égale au nombre lui-même. Pour mieux comprendre le concept de nombre fort, jetez un œil à l'exemple ci-dessous :

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

Le nombre 145 est un nombre fort. En effet, si nous additionnons les factorielles de chaque chiffre de ce nombre, vous obtiendrez le nombre, qui est lui-même 145, comme somme. 1 ! +4 ! +5 ! = 1 + 24 + 120 = 145.

Voyons maintenant la logique de vérifier si un nombre est un nombre fort ou non en Java. Vous trouverez ci-dessous la description de la vérification si un nombre est un nombre fort ou non.

• Prenez un nombre défini par l'utilisateur ou un nombre comme entrée de l'utilisateur. Stockez ce numéro dans une variable définie par l'utilisateur. Copiez maintenant ce numéro dans une autre variable temporaire définie par l'utilisateur. Cette variable sera utilisée à des fins de calcul. Vous pouvez nommer la variable définie par l'utilisateur comme « n » et la variable temporaire comme « temp_n ».
• Maintenant, initialisez une autre variable qui stockera la somme des chiffres factoriels. Vous pouvez nommer cette variable comme « total ».
• Vous devrez également trouver le dernier chiffre du nombre « n » donné. Stockez ce résultat dans une variable qui stockera le résultat, disons « lastdig = n % 10 ».
• Vous pouvez maintenant trouver la factorielle de « lastdig ». Vous pouvez maintenant stocker la factorielle de ce nombre et la nommer « fact_n ».
• Une fois cela fait, vous pouvez ajouter la factorielle au « total ». Cela peut être fait en utilisant total = total + fact_n.
• Vous pouvez maintenant supprimer le dernier chiffre de « n » car il ne sera plus nécessaire.
• Maintenant, répétez les étapes de l'étape 3 à l'étape 6 jusqu'à ce que la condition n > 0 est satisfait.
• Vous pouvez utiliser une boucle pour cela. Il peut être utilisé pour vérifier l’état d’un nombre fort. Si la condition total == temp_n est satisfaite, alors le nombre donné est un nombre fort, sinon il ne l'est pas.

Exemples de nombre fort en Java

Il est très simple d'implémenter la logique d'un nombre fort en Java ; regardons quelques exemples ci-dessous.

Exemple n°1

Code :

// Program in Java to check if a given number is a strong number or not
import java.util.*;
public class Main
{
public static void main(String[] args) {
int n,i;
int fact_n,lastdig;
Scanner sc = new Scanner(System.in);
System.out.print("\nEnter the number : " );
n = sc.nextInt();
int total = 0;
int temp_n = n;
while(n != 0)
{
i = 1;
fact_n = 1;
lastdig = n % 10;
while(i <= lastdig)
{
fact_n = fact_n * i;
i++;
}
total = total + fact_n;
n = n / 10;
}
if(total == temp_n)
System.out.println(temp_n + " is a strong number\n");
else
System.out.println(temp_n + " is not a strong number\n");
System.out.println();
}
}

Sortie :

Le programme Java ci-dessus contient toutes les variables décrites dans la logique du programme. Il trouve d'abord le mod ou le dernier chiffre du nombre jusqu'à ce que le nombre ne soit pas nul. Une fois cela fait, il incrémente le nombre et le stocke dans fact_n pour connaître la factorielle du nombre. Le total ou l'addition n'est pas dans une boucle while où les factorielles sont ajoutées jusqu'à ce que la condition i<= lastdig ne soit pas satisfaite. Après l'ajout de « total » et que fact_n n'est pas égal à « temp_n », alors le nombre donné n'est pas factoriel. En revanche, si le total et fact_n sont identiques, alors le nombre mentionné est un nombre fort.

Exemple n°2

Une autre façon de trouver un nombre fort consiste à utiliser des nombres forts. Le numéro ici peut être transmis au programme en utilisant le paramètre de ligne de commande.

Code :

public class Main
{
static int f[] = new int[10];
// Finding factorial for number 0 to 9
static void FirstCompute()
{
f[0] = f[1] = 1;
for (int i = 2; i<10; ++i)
f[i] = f[i-1] * i;
}
// If x is strong true is returned
static boolean isStrong(int x)
{
int Sum_fact = 0;
// Traverse through all digits of x.
int temp_n = x;
while (temp_n>0)
{
Sum_fact += f[temp_n%10];
temp_n /= 10;
}
return (Sum_fact == x);
}
// main function
public static void main (String[] args)
{
// calling preCompute
FirstCompute();
// first pass
int x = 145;
if(isStrong(x))
{
System.out.println("Yes");
}
else
System.out.println("No");
// second pass
x = 534;
if(isStrong(x))
{
System.out.println("Yes");
}
else
System.out.println("No");
}
}

C'est une autre façon de savoir si le nombre est un nombre fort ou non. Ici, vous pouvez récupérer les entrées de l'utilisateur pendant l'exécution en utilisant les arguments de ligne de commande. La logique reste ici la même, la différence étant que l'entrée est envoyée sous forme d'arguments au moment de l'exécution. La sortie de ce programme sera OUI ou NON, selon que le nombre est fort ou non.

Sortie :

Le programme ici vérifie deux nombres, s'ils sont forts ou non. Ici, il découvre les factorielles de tous les chiffres de 0 à 9. La fonction isStrong valide ensuite si le nombre est fort ou non. Il parcourra tous les chiffres du numéro donné jusqu'à ce que le mod existe. La fonction principale valide ici si la fonction precompute() donne des résultats corrects. Deux numéros sont acceptés d'un utilisateur, ce qui permet de vérifier et de fournir si le numéro est un nombre fort ou non. La fonction principale appelle d'abord la fonction qui calcule la factorielle de chaque chiffre. La fonction isStrong() vérifie ensuite la somme de la factorielle de chaque chiffre. Il le calcule également et renvoie le résultat sous une valeur booléenne, qui est vraie ou fausse. Dans l'ensemble, seul le passage du nombre fournira le résultat selon le résultat mentionné. Si le nombre est fort, true sera renvoyé par la fonction isStrong, et s'il ne l'est pas, false sera renvoyé.

Conclusion

Un nombre fort est un nombre dont la somme de la factorielle de chaque chiffre est le nombre lui-même. Une fonction Java normale, ou une fonction utilisant des valeurs booléennes ou en passant simplement les nombres comme arguments, un nombre fort peut être identifié. La logique utilise des opérations simples comme un mod, une division et une addition.

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!