Java Program to Check Armstrong Number

An Armstrong Number in Java is a unique integer where the sum of the cubes of its individual digits equals the number itself. Examples of Armstrong numbers include 0, 1, 153, 370, 371, 407, and more.

How to Identify Armstrong Numbers?

Identifying Armstrong numbers involves a simple algorithm:

1. Count the number of digits (n) in the given number.
2. Extract each digit of the number.
3. Raise each digit to the power of n.
4. Sum all the results.
5. Check if the sum is equal to the original number. If it is, the number is an Armstrong number.

Formula to calculate Armstrong Number:

wxyz = pow(w,n) + pow(x,n) + pow(y,n) + pow(z,n)

Example:

Let’s look at 371 as an example to understand why it’s an Armstrong number.

371 = 3*3*3 + 7*7*7 + 1*1*1 
    = 27 + 343 +  1
    = 371

Write a Java program to check if a given number is Armstrong. If the number is an Armstrong then display it is an Armstrong number else display it is not an Armstrong number.

There are several ways to find armstrong number in Java language. Let’s take a detailed look at all the approaches to find armstrong number in Java.

• Armstrong Number in Java using While Loop
• Armstrong Number in Java using For Loop

In this approach, we utilize a Java program to check whether a given number is an Armstrong number. This method utilizes a while loop for the calculations.

Here is the source code of the Java Program to Check If a Given Number is ArmStrong Number. The Java program is successfully compiled and run on a Windows system. The program output is also shown below.

/*
 * Armstrong Number in Java using While Loop
 */
 
import java.util.Scanner;
public class ArmStrong 
{
    public static void main(String[] args) 
    {
        int n, count = 0, a, b, c, sum = 0;
        Scanner s = new Scanner(System.in);
        System.out.print("Enter a number:");
        n = s.nextInt();
        a = n;
        c = n;
        while(a > 0)
        {
            a = a / 10;
            count++;
        }
        while(n > 0)
        {
            b = n % 10;
            sum = (int) (sum+Math.pow(b, count));
            n = n / 10;
        }
        if(sum == c)
        {
            System.out.println(c+ " is an Armstrong number");
        }
        else
        {
            System.out.println(c+ " is not an Armstrong number");
        }    
    }
}

1. Take the number as input and store it in the variable “n“.
2. Initialize variables “count”, “a”, “b”, “c”, and “sum” to keep track of the calculation.
3. Use a while loop to count the number of digits in the input number and store it in the “count” variable.
4. Use another while loop to calculate the sum of the cubes of each digit in the input number and store it in the “sum” variable.
5. Check if the calculated sum is equal to the original number “c”.
6. If the sum is equal to “c”, print that it’s an Armstrong number; otherwise, print that it’s not.

Time Complexity: O(log(n))
The program has a time complexity of O(log(n)) because both while loops run for log(n) iterations. In each iteration, the number is divided by 10 until it becomes 0.

Space Complexity: O(1)
The space complexity of the program is O(1) because it uses a fixed number of variables, and no additional space grows with the input size.

Testcase 1: In this case, we enter the number “371” as input to check whether it is a armstrong number or not.

 
Enter a number: 371
371 is an Armstrong number

Testcase 2: In this case, we enter the number “150” as input to check whether it is a prime number or not.

Enter a number: 150
150 is not an Armstrong number

This Java program checks whether a given number is an Armstrong number using for loops, calculating the number of digits and the sum of cubes of digits.

Here is the source code of the Java Program to Check If a Given Number is Armstrong Number using for loop. The Java program is successfully compiled and run on a Windows system. The program output is also shown below.

/*
 * Armstrong Number in Java using For Loop
 */
 
import java.util.Scanner;
 
public class ArmStrong
{
    public static void main(String[] args)
    {
        int n, count = 0, a, b, c, sum = 0;
        Scanner s = new Scanner(System.in);
        System.out.print("Enter a number:");
        n = s.nextInt();
        a = n;
        c = n;
 
        // Calculate the number of digits in 'n' using a for loop
        for (; a > 0; a /= 10)
        {
            count++;
        }
 
        // Reset 'a' and 'sum' for the following loop
        a = n;
        sum = 0;
 
        // Calculate the sum of cubes of digits using a for loop
        for (; n > 0; n /= 10)
        {
            b = n % 10;
            sum += Math.pow(b, count);
        }
 
        if (sum == c)
        {
            System.out.println(c + " is an Armstrong number");
        }
        else
        {
            System.out.println(c + " is not an Armstrong number");
        }
    }
}

1. First, we take an integer input “n” from the user.
2. Then, we initialize variables to perform calculations.
3. Using a loop, we count the number of digits in “n”.
4. Another loop calculates the sum of the cubes of each digit.
5. We check if this calculated sum is equal to the original number.
6. Finally, we display the result, indicating whether it’s an Armstrong number or not.

The Java program using for loops to check for Armstrong numbers has a time complexity of O(log(n)) as both loops run for log(n) iterations. Its space complexity is O(1) since it uses a fixed number of variables, regardless of the input size.

Testcase 1: In this case, we enter the number “153” as input to check whether it is a armstrong number or not.

 
Enter a number: 153
153 is an Armstrong number

Testcase 2: In this case, we enter the number “442” as input to check whether it is a prime number or not.

Enter a number: 442
442 is not an Armstrong number

To practice programs on every topic in Java, please visit “Programming Examples in Java”, “Data Structures in Java” and “Algorithms in Java”.