Armstrong-Zahl in Java

Armstrong-Zahl in Java Armstrong ist eine Zahl, bei der die Summe der Kubikzahlen der einzelnen Ziffern der Zahl gleich der Zahl selbst ist. Die Armstrong-Zahl ist eine besondere Art von Zahl, bei der zunächst die Ziffern aufgenommen, dann gewürfelt und schließlich alle Würfel der einzelnen Ziffern addiert werden, um eine Zahl zu erhalten. Wenn die so gefundene Zahl mit der ursprünglichen Zahl übereinstimmt, wird die entsprechende Zahl als Armstrong-Zahl bezeichnet. Ein Beispiel für Armstrongs Zahl ist 153. Wenn wir die Ziffern von 153 zerlegen, sind es 1, 5 und 3. Dann ermitteln wir die Potenz der jeweiligen Zahlen und berechnen schließlich die Potenz der Zahlen.

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

Auf diese Weise können wir berechnen, ob eine Zahl eine Armstrong-Zahl ist oder nicht.

Beispiele für Armstrong-Zahlen in Java

Wir werden die Veranschaulichung anhand von Beispielen sehen.

Beispiel #1

Im Codierungsbeispiel verwenden wir die Programmiersprache Java, um zu bestimmen, ob die Zahl eine Armstrong-Zahl ist oder nicht. Wenn es sich bei der eingegebenen Nummer um eine Armstrong-Nummer handelt, gibt das Programm sie automatisch als Armstrong-Nummer aus. Wenn es sich nicht um eine handelt, antwortet es automatisch, dass es sich bei der Nummer nicht um eine Armstrong-Nummer handelt. Wir können dreistellige oder vierstellige Werte eingeben, um zu prüfen, ob es sich bei der Zahl um eine Armstrong-Zahl handelt oder nicht.

Die Logik des Programms ist so, dass jede Ziffer der jeweiligen Zahl in der temporären Variablen gespeichert wird. Dann wird die Zahl gewürfelt, um den Würfel der jeweiligen Ziffer zu ermitteln, der in einer anderen Variablen „Summe“ gespeichert wird. Abschließend wird die Gesamtzahl mit der entsprechenden Originalzahl überprüft. Die Ziffern werden einzeln ermittelt, indem die Zahl bei jedem Schritt durch 10 geteilt wird, dann der Rest der Zahl ermittelt wird und dann die Zahl gewürfelt wird, um den Würfel der jeweiligen Ziffer zu erhalten.

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");
}
}

Ausgabe:

Im ersten Programm geben wir die Zahlen 370 und 153 als Zahlen ein, um zu prüfen, ob es sich um Armstrong handelt oder nicht. Außerdem geben wir 269 als Zahl ein, um zu prüfen, ob es sich bei der Zahl um Armstrong handelt. Wir erhalten die entsprechende Ausgabe des Programms, dass die Zahlen 370 und 153 Armstrong-Zahlen sind, während die Zahl 269 keine Armstrong-Zahl ist.

Beispiel #2

Im zweiten Codierungsbeispiel wählen wir einen Zahlenbereich aus, der überprüft, ob es sich um Armstrong-Zahlen handelt oder nicht. Der Bereich liegt zwischen 150 und 160. Wir wählen den Bereich aus und überprüfen die Ausgabe, ob es sich bei der Zahl um eine Armstrong-Zahl handelt oder nicht. Dann sehen wir die Ausgabe. Die verwendete Logik ähnelt der Logik, die zum Ermitteln einer Armstrong-Zahl verwendet wird. Die jeweiligen Ziffern der Zahl werden berechnet, dann werden sie gewürfelt und summiert, um die endgültige Gesamtzahl zu ermitteln. Wenn die endgültige Gesamtzahl der ursprünglichen Zahl entspricht, gelten sie als berechnete Armstrong-Zahlen.

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");
}
}
}

Ausgabe:

In der Beispielausgabe sehen wir, dass alle Zahlen im Bereich von 150 bis 160 daraufhin überprüft wurden, ob es sich um Armstrong-Zahlen handelt oder nicht. Das Programm hat gemeldet, dass nur 153 eine Armstrong-Zahl ist, deren Ziffernsumme der ursprünglichen Zahl entspricht. Alle anderen Zahlen wurden als Nicht-Armstrong-Zahlen gemeldet.

Beispiel #3

In diesem Codierungsbeispiel sehen wir die Liste der Armstrong-Zahlen zwischen 365 und 375. Wir ändern den Bereich der Werte, die auf Armstrong-Zahlen überprüft werden sollen. Die Beispiellogik der Codierung ist genau die gleiche wie bei den vorherigen. Der Hauptunterschied besteht darin, dass der Bereich der zu prüfenden Zahlen geändert wird und sie sich geringfügig von der letzten Codezeile unterscheiden.

Die einzelnen Ziffern werden genommen, gewürfelt und summiert, um eine Zahl zu erhalten. Wenn diese Zahl mit der ursprünglichen Zahl übereinstimmt, wird die ursprüngliche Zahl als Armstrong-Zahl bezeichnet; andernfalls handelt es sich nicht um eine Armstrong-Zahl.

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");
}
}
}

Ausgabe:

In der Beispielausgabe des Programms sehen wir, dass nur 371 und 370 Armstrong-Zahlen sind, während dies bei den anderen Zahlen nicht der Fall ist, da die Summe der Potenzen der einzelnen Ziffern nicht die ursprüngliche Zahl ergibt.

Fazit – Armstrong-Zahl in Java

In diesem Artikel haben wir die Funktionsweise und Definition einer Armstrong-Zahl gesehen. Zunächst prüfen wir, ob es sich bei einer eingegebenen Zahl um eine Armstrong-Zahl handelt oder nicht. Zweitens geben wir einen Wertebereich von 150 bis 160 ein und prüfen, wie viele Armstrong-Zahlen zwischen diesen Werten liegen. Drittens geben wir einen Zahlenbereich von 365 bis 375 ein und stellen fest, dass 370 und 371 Armstrong-Zahlen sind. Armstrong-Zahlen sind spezielle Zahlen, die in der Zahlentheorie verwendet werden und können verwendet werden, um die Art der Ziffern einiger Zahlen und die Summe ihrer Kubikzahlen zu ermitteln.

Das obige ist der detaillierte Inhalt vonArmstrong-Zahl in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!