Numéro Armstrong en Java

Le nombre Armstrong en Java Armstrong est un nombre dans lequel la somme des cubes des chiffres individuels du nombre est égale au nombre lui-même. Le nombre d'Armstrong est un type spécial de nombre dans lequel les chiffres sont d'abord ramassés, puis ils sont coupés en cubes et enfin, tous les cubes des chiffres individuels sont additionnés pour obtenir un nombre. Si le nombre ainsi trouvé est égal au nombre d’origine, alors le nombre respectif est appelé nombre d’Armstrong. Un exemple du nombre d'Armstrong est 153. Si nous décomposons les chiffres de 153, ce sont 1, 5 et 3. Ensuite, nous trouvons le cube des nombres respectifs, et enfin, nous calculons le cube des nombres.

153= (1*1*1)+(5*5*5)+(3*3*3)
370= (3*3*3)+(7*7*7)+(0*0*0)

De cette façon, nous pouvons calculer si un nombre est un nombre d'Armstrong ou non.

Exemples de nombre d'Armstrong en Java

Nous verrons l'illustration à l'aide d'exemples.

Exemple n°1

Dans l'exemple de codage, nous utilisons le langage de programmation Java pour déterminer si le numéro est un numéro Armstrong ou non. Si le numéro saisi est un numéro Armstrong, alors le programme l'imprime automatiquement comme un numéro Armstrong, et s'il n'en est pas un, il répond automatiquement que le numéro n'est pas un numéro Armstrong. Nous pouvons saisir des valeurs à trois ou quatre chiffres pour vérifier si le numéro est un numéro Armstrong ou non.

La logique du programme est telle que chaque chiffre du numéro respectif est stocké dans la variable temporaire. Ensuite, le nombre est divisé en cubes pour connaître le cube du chiffre respectif, qui est stocké dans un autre total variable. Enfin, le nombre total est vérifié avec le numéro d'origine correspondant. Les chiffres sont obtenus un par un en divisant le nombre par 10 à chaque étape, puis en obtenant le reste du nombre, puis en coupant le nombre au cube pour obtenir le cube du chiffre respectif.

Code :

import java.io.*;
public class Armstrong
{
public static void main(String[] args)throws IOException
{
BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter a number");
int num = Integer.parseInt(br.readLine());
int number, digit, sum = 0;
number = num;
while (number != 0)
{
digit = number % 10;
sum = sum + digit*digit*digit;
number /= 10;
}
if(sum == num)
System.out.println(num + " is an Armstrong number");
else
System.out.println(num + " is not an Armstrong number");
}
}

Sortie :

Dans le premier programme, nous saisissons les nombres 370 et 153 comme nombres pour vérifier s'il s'agit d'Armstrong ou non. De plus, nous saisissons 269 comme nombre pour vérifier si le numéro est Armstrong. Nous obtenons le résultat respectif du programme selon lequel les nombres 370 et 153 sont des nombres d'Armstrong tandis que le nombre 269 n'est pas un nombre d'Armstrong.

Exemple n°2

Dans le deuxième exemple de codage, nous sélectionnons une plage de nombres qui sont vérifiés s'il s'agit de nombres Armstrong ou non. La plage est de 150 à 160. Nous sélectionnons la plage et vérifions le résultat si le nombre est un nombre Armstrong ou non. Ensuite, nous voyons le résultat. La logique utilisée est similaire à celle utilisée pour trouver un nombre d'Armstrong. Les chiffres respectifs du nombre sont calculés, puis ils sont divisés en cubes et additionnés pour trouver le nombre total final. Si le nombre total final est égal au nombre d'origine, ils sont considérés comme des nombres Armstrong calculés.

Code :

import java.io.*;
public class ArmstrongRange
{
public static void main(String[] args)throws IOException
{
for(int num= 150; num<160; num++)
{
int number, digit, sum = 0;
number = num;
while (number != 0)
{
digit = number % 10;
sum = sum + digit*digit*digit;
number /= 10;
}
if(sum == num)
System.out.println(num + " is an Armstrong number");
else
System.out.println(num + " is not an Armstrong number");
}
}
}

Sortie :

Dans l'exemple de sortie, nous voyons que tous les nombres compris entre 150 et 160 ont été vérifiés pour savoir s'il s'agit de nombres Armstrong ou non. Le programme a rapporté que seul 153 est un nombre d'Armstrong dont la somme des cubes de chiffres est égale au nombre d'origine. Tous les autres numéros ont été signalés comme des numéros non Armstrong.

Exemple #3

Dans cet exemple de codage, nous verrons la liste des nombres Armstrong présents entre 365 et 375. Nous modifions la plage des valeurs à vérifier pour les nombres Armstrong. L'exemple de logique de codage est exactement le même que les précédents. La principale différence est que la plage de nombres à vérifier est modifiée et qu'ils sont légèrement différents de la dernière ligne de code.

Les chiffres individuels sont pris, coupés en cubes et additionnés pour obtenir un nombre. Si ce numéro est le même que le numéro d’origine, alors le numéro d’origine est appelé numéro Armstrong ; sinon, ce n'est pas un numéro Armstrong.

Code :

import java.io.*;
public class ArmstrongRange
{
public static void main(String[] args)throws IOException
{
for(int num= 365; num<375; num++)
{
int number, digit, sum = 0;
number = num;
while (number != 0)
{
digit = number % 10;
sum = sum + digit*digit*digit;
number /= 10;
}
if(sum == num)
System.out.println(num + " is an Armstrong number");
else
System.out.println(num + " is not an Armstrong number");
}
}
}

Sortie :

Dans l'exemple de sortie du programme, nous voyons que seuls 371 et 370 sont des nombres d'Armstrong, tandis que les autres nombres ne le sont pas, car la somme des cubes des chiffres individuels ne correspond pas au nombre d'origine.

结论 – Java 中的阿姆斯特朗数

在本文中，我们了解了阿姆斯特朗数的工作原理和定义。首先，我们检查输入的数字是否是阿姆斯特朗数字。其次，我们输入 150 到 160 之间的一系列值，并检查这些值之间有多少个阿姆斯特朗数。第三，我们输入365到375之间的数字，发现370和371是阿姆斯特朗数。阿姆斯特朗数是数论中使用的特殊数字，可用于求某些数字的数字性质及其立方和。

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!