Wat is Armstrong Number op Java?
Armstrong-nummer in Java, Armstrong is er een waarin de som van de kubussen van de individuele cijfers van het nummer gelijk is aan het nummer zelf. Armstrong-nummer is een speciaal soort nummer waarbij de cijfers eerst worden opgepikt, vervolgens worden ze in een kubus geplaatst en tenslotte worden alle kubussen van de afzonderlijke cijfers toegevoegd om een nummer te krijgen. Als het aldus gevonden nummer gelijk is aan het oorspronkelijke nummer, staat het betreffende nummer bekend als een Armstrong-nummer. Een voorbeeld van het getal van Armstrong is 153. Als we de cijfers van 153 opsplitsen, zijn dat 1, 5 en 3. Dan vinden we de kubus van de respectieve getallen en ten slotte berekenen we de kubus van de getallen.
153= (1*1*1)+(5*5*5)+(3*3*3)
370= (3*3*3)+(7*7*7)+(0*0*0)
Op deze manier kunnen we berekenen of een nummer een Armstrong-nummer is of niet.
Voorbeelden van Armstrong Number in Java
We zullen de illustratie van het Armstrong-nummer in Java zien, met behulp van voorbeelden.
Voorbeeld 1
In het coderingsvoorbeeld gebruiken we Java-programmeertaal om te bepalen of het nummer een Armstrong-nummer is of niet. Als het ingevoerde nummer een Armstrong-nummer is, drukt het programma het automatisch af als een Armstrong-nummer en als het niet één is, antwoordt het automatisch dat het nummer geen Armstrong-nummer is. We kunnen waarden van drie of vier cijfers invoeren om te controleren of het nummer een Armstrong-nummer is of niet.
De logica van het programma is zodanig dat in de tijdelijke variabele elk cijfer van het respectieve nummer wordt opgeslagen. Vervolgens wordt het nummer gekubeerd om de kubus van het respectieve cijfer te achterhalen die in een ander variabel totaal wordt opgeslagen. Ten slotte wordt het totale aantal gecontroleerd met het bijbehorende originele nummer. De cijfers worden één voor één verkregen door het nummer bij elke stap gedeeld door 10 te krijgen en vervolgens de rest van het nummer te krijgen en vervolgens het nummer te kuberen om de kubus van het respectieve cijfer te krijgen.
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");
)
)
Output:
In het eerste programma voeren we de nummers 370 en 153 in als nummers om te controleren of ze Armstrong zijn of niet. We voeren ook 269 in als een nummer om te controleren of het nummer Armstrong is. We krijgen de respectieve uitvoer van het programma dat de nummers 370 en 153 Armstrong-nummers zijn, terwijl het nummer 269 geen Armstrong-nummer is.
Voorbeeld 2
In het tweede coderingsvoorbeeld selecteren we een reeks getallen die worden gecontroleerd of ze Armstrong-nummers zijn of niet. Het bereik ligt tussen 150 en 160. We selecteren het bereik en we controleren de uitvoer of het nummer een Armstrong-nummer is of niet. Dan zien we de output. De gebruikte logica is vergelijkbaar met die van de logica die wordt gebruikt voor het vinden van een Armstrong-nummer. De respectieve cijfers van het nummer worden berekend en vervolgens worden ze in een blok gezet en opgeteld om het uiteindelijke totale aantal te vinden. Als het uiteindelijke totale aantal gelijk is aan het oorspronkelijke aantal, worden ze beschouwd als Armstrong-nummers die worden berekend.
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");
)
)
)
Output:
In de voorbeelduitvoer zien we dat alle getallen in het bereik van 150 tot 160 zijn gecontroleerd op het feit of ze Armstrong-nummers zijn of niet. Het programma heeft gemeld dat slechts 153 een Armstrong-nummer is waarvan de som van de cijfers gelijk is aan het oorspronkelijke nummer. Alle andere nummers zijn gerapporteerd als niet-Armstrong-nummers.
Voorbeeld 3
In dit coderingsvoorbeeld gaan we de lijst met Armstrong-nummers zien die aanwezig zijn tussen 365 en 375. We wijzigen het bereik van de waarden die moeten worden gecontroleerd op Armstrong-nummers. De voorbeeldlogica van de codering is exact hetzelfde als de vorige. Het belangrijkste verschil is alleen dat het bereik van de te controleren nummers is gewijzigd en ze een beetje verschillen van de laatste regel code.
De individuele cijfers worden genomen, in blokjes en opgeteld om een nummer te krijgen. Als dat nummer hetzelfde is als het oorspronkelijke nummer, staat het oorspronkelijke nummer bekend als een Armstrong-nummer, anders is het geen Armstrong-nummer.
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");
)
)
)
Output:
In de voorbeelduitvoer die door het programma wordt gegeven, zien we dat alleen 371 en 370 Armstrong-nummers zijn, terwijl de andere nummers niet zijn omdat de som van de kubussen van de individuele cijfers niet optelt bij het oorspronkelijke nummer.
Conclusie - Armstrong-nummer in Java
In dit artikel hebben we de werking en definitie van een Armstrong-nummer gezien. Eerst controleren we of een ingevoerd nummer een Armstrong-nummer is of niet. Ten tweede voeren we een bereik van waarden van 150 tot 160 in en controleren we hoeveel Armstrong-nummers er tussen die waarden staan. Ten derde voeren we een reeks getallen in van 365 tot 375 en ontdekken dat 370 en 371 Armstrong-getallen zijn. Armstrong-getallen zijn speciale getallen die in de getaltheorie worden gebruikt en kunnen worden gebruikt om de aard van cijfers van sommige getallen te bepalen, samen met de sommatie van hun kubussen.
Aanbevolen artikelen
Dit is een gids geweest voor het Armstrong-nummer in Java. Hier laten we zien hoe we het Armstrong-nummer in Java kunnen illustreren met behulp van enkele voorbeelden. U kunt ook de volgende artikelen bekijken voor meer informatie–
- Statisch trefwoord in Java
- Palindrome in Java
- Overschrijven in Java
- Random Number Generator in Java