Armstrong Number in Java: Methods & Examples

An Armstrong number program in Java referred to as a Narcissistic number or Pluperfect digital invariant, is a number that is the sum of its digits, with each digit raised to the power of the total number of digits.

For a number with n digits, the Armstrong number can be described by the following condition:

Formula 

The formula for an Armstrong number is as follows:

Armstrong Number = d₁ⁿ+d₂ⁿ+⋯+d_mⁿ

Where:

• d₁+d₂+⋯+d_m  are the digits of the number. For example in 370, the digits are 3,7 and 0
• n represents the total number of digits in the number. For example in 370, the total number of digits = 3 

Another example

1. 153 is an Armstrong number because it consists of 3 digits:

                     1³ +5 ³+3³ =153 (i.e., 1 + 125 + 27 = 153)

2. 9474 is another Armstrong number because it has 4 digits:

                    9⁴+4⁴+7⁴+4⁴=9474 (i.e., 6561 + 256 + 2401 + 256 = 9474)

Real-World Applications 

While Armstrong numbers might seem like a fun mathematical curiosity, they serve a real purpose in programming, particularly when learning how to:

• Use loops and conditional statements.
• Break down problems into smaller, manageable tasks.
• Work with numerical operations and recursion.

These concepts are foundational for Java beginners, especially when preparing for interviews or competitive programming challenges.

There are multiple ways to check if a number is an Armstrong number in Java. Here, we will discuss the naive approach, the advanced approach using strings, and how to implement it using loops and recursion.

Below is the Java program for Armstrong numbers to check whether the number is an Armstrong number or not:

Using a Naive Approach

The simplest way to check for an Armstrong number is to extract each digit of the number, raise it to the power of the total number of digits, and compare the sum of these values to the original number.

Algorithm

• Take an input number.
• Determine the number of digits (n).
• For each digit in the number, raise it to the power of n and add it to a sum.
• If the sum equals the original number, it is an Armstrong number.
• This method is easy to understand but may not be the most efficient.

Below is the program to check whether the number is an Armstrong number or not:

Java Code 

public class Armstrong {
    public static void main(String[] args) {
        int num = 153, originalNum = num, sum = 0;
        int digits = 0;

        // Count number of digits
        while (num != 0) {
            num /= 10;
            digits++;
        }

        num = originalNum;
        // Check Armstrong condition
        while (num != 0) {
            int digit = num % 10;
            sum += Math.pow(digit, digits);
            num /= 10;
        }

        // Output result
        if (sum == originalNum)
            System.out.println(originalNum + " is an Armstrong number.");
        else
            System.out.println(originalNum + " is not an Armstrong number.");
    }
}

Code Explanation

• The first while loop counts the number of digits in the input number.
• The second while loop extracts each digit, raises it to the power of the total digits, and adds it to sum.
• If the sum equals the original number, it prints that the number is an Armstrong number.

Output

153 is an Armstrong number.

Advanced Approach Using Numeric Strings

Another approach involves converting the number to a string. Since, using astring we can  split the digits, and then operate on a single digit using string manipulation techniques. This can simplify the process when handling complex numbers.

Benefits of Using This Approach

• Allows for easy digit manipulation.
• Makes it simpler to work with numbers of varying lengths.
• Often easier to read and debug.

Algorithm 

• Convert the number to a string.
• Determine the number of digits (length of the string).
• For each character in the string, convert it back to an integer, raise it to the power of the number of digits, and add it to a sum.
• If the sum equals the original number, it's an Armstrong number.

Code

public class Armstrong {
    public static void main(String[] args) {
        int num = 153;
        String strNum = Integer.toString(num);
        int digits = strNum.length();
        int sum = 0;
        int originalNum = num;

        for (int i = 0; i < digits; i++) {
            int digit = strNum.charAt(i) - '0';  // Convert char to int
            sum += Math.pow(digit, digits);
        }

        if (sum == originalNum)
            System.out.println(originalNum + " is an Armstrong number.");
        else
            System.out.println(originalNum + " is not an Armstrong number.");
    }
}

Output

153 is an Armstrong number.

Code Explanation

• In this approach, the number is first converted to a string, allowing easy access to each digit. Each digit is raised to the power of the total number of digits, summed up, and then compared with the original number to check if it's an Armstrong number
• This method simplifies digit manipulation and enhances readability.

Armstrong Java Program Using Loops

In this section, we will explore two different loop-based approaches to check if a number is an Armstrong number in Java: using a while loop and a for loop. Each approach will be explained step by step:

Armstrong Number in Java Using “While” Loop

A while loop iterates through each digit of the number, calculates the sum of the digits raised to the power of the total number of digits, and checks whether the sum equals the original number.

Java Code

public class ArmstrongNumber {
    public static void main(String[] args) {
        int num = 153; // Input number
        int originalNum = num; // Store original number for comparison
        int sum = 0; // Initialize sum of digits raised to power
        int digits = String.valueOf(num).length(); // Find the number of digits

        // While loop to calculate the sum of digits raised to the power of digits
        while (num != 0) {
            int remainder = num % 10; // Extract last digit
            sum += Math.pow(remainder, digits); // Add raised power of digit to sum
            num /= 10; // Remove the last digit
        }

        // Check if the sum equals the original number
        if (sum == originalNum) {
            System.out.println(originalNum + " is an Armstrong number.");
        } else {
            System.out.println(originalNum + " is not an Armstrong number.");
        }
    }
}

Output

153 is an Armstrong number.

Explanation

• The input number is 153.
• We calculate the number of digits by converting the number to a string and getting the length.
• Using the while loop, we continuously extract the last digit using num % 10, raise it to the power of the number of digits, and add it to the sum.
• After processing each digit, we remove the last digit by dividing the number by 10 (num /= 10).
• After exiting the loop, we check if the sum equals the original number.

Armstrong Number in Java Using For Loop

A for loop can also be used to achieve the same result. It is often preferred when you know the number of iterations in advance or when iterating over a fixed set of items.

Java Code

public class ArmstrongNumber {
    public static void main(String[] args) {
        int num = 153; // Input number
        int originalNum = num; // Store original number for comparison
        int sum = 0; // Initialize sum of digits raised to power
        int digits = String.valueOf(num).length(); // Find the number of digits

        // For loop to calculate the sum of digits raised to the power of digits
        for (; num != 0; num /= 10) {
            int remainder = num % 10; // Extract last digit
            sum += Math.pow(remainder, digits); // Add raised power of digit to sum
        }

        // Check if the sum equals the original number
        if (sum == originalNum) {
            System.out.println(originalNum + " is an Armstrong number.");
        } else {
            System.out.println(originalNum + " is not an Armstrong number.");
        }
    }
}

Output

153 is an Armstrong number.

Explanation

• The program logic is the same as the while loop implementation, but here, we use a for loop.
• We initialize the loop with num != 0 as the condition, and for each iteration, we extract the last digit, calculate the power, and remove the last digit (by dividing num by 10).
• The difference between a for loop and a while loop is that the for loop is more compact and allows you to specify the increment/decrement directly in the loop declaration.

Armstrong Java Program Using Recursion

The recursive method checks if a number is an Armstrong number by breaking the number into digits, raising each digit to the power of 3, summing the results, and comparing it with the original number.

Algorithm

• Loop through numbers from 1 to 1000.
• For each number, recursively calculate the sum of the cubes of its digits.
• If the sum equals the original number, print it as an Armstrong number.

Java Code

class ArmstrongRecursion {
    int findArmstrong(int n, int sum) {
        if (n == 0) return sum;
        int digit = n % 10;
        return findArmstrong(n / 10, sum + digit * digit * digit);
    }

    public static void main(String[] args) {
        ArmstrongRecursion A = new ArmstrongRecursion();
        System.out.println("Armstrong numbers between 1 to 1000:");
        for (int num = 1; num < 1000; num++) {
            if (A.findArmstrong(num, 0) == num) {
                System.out.println(num);
            }
        }
    }
}

Output

Armstrong numbers between 1 to 1000:
1
153
370
371
407

Explanation

• This program identifies Armstrong numbers between 1 and 1000 using recursion. It calculates the sum of the cubes of each digit and compares it with the original number.
• If they are equal, the number is printed as an Armstrong number.
• Examples of Armstrong numbers include 1, 153, 370, 371, and 407.

Armstrong numbers can exist with any number of digits, though they become rarer as the number of digits increases. Let's consider different scenarios based on varying digit lengths:

3-Digit Armstrong Numbers

The well-known 3-digit Armstrong numbers are numbers where the sum of the cubes of their digits equals the number itself. For example:

• 153: 1³  +  5³ + 3³    = 1 + 125 + 27  = 153
• 370: 3³  + 7³  + 0³   = 27 + 343 + 0 = 370
• 371: 3³  + 7³  + 1³   = 27 + 343 + 1 = 371

4-Digit Armstrong Numbers

A 4-digit Armstrong number is a number where the sum of the fourth powers of its digits equals the number itself. For example:

• 1634: 1⁴  + 6⁴  +3⁴ + 4⁴  = 1 + 864 + 81 + 192 = 1634

Checking Armstrong Numbers Between Two Integers

A 2-digit Armstrong number would be a number where the sum of its digits squared equals the number itself. However, this is impossible because the largest sum of squares of two digits (i.e., 

9²+9²=81+81=162 is much larger than any two-digit number. Therefore, no 2-digit Armstrong numbers exist.

1. Java Program to Find Armstrong Numbers in a Given Range

Here is a Java program to find Armstrong numbers within a given range, excluding the non-existent 2-digit numbers:

Java Code

import java.util.Scanner;

public class ArmstrongInRange {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter the lower bound: ");
        int lower = sc.nextInt();
        System.out.print("Enter the upper bound: ");
        int upper = sc.nextInt();

        System.out.println("Armstrong numbers between " + lower + " and " + upper + " are:");
        for (int num = lower; num <= upper; num++) {
            if (isArmstrong(num)) {
                System.out.println(num);
            }
        }
    }

    public static boolean isArmstrong(int num) {
        int sum = 0;
        int originalNumber = num;
        int digits = String.valueOf(num).length();
        
        while (num != 0) {
            int digit = num % 10;
            sum += Math.pow(digit, digits);
            num /= 10;
        }

        return sum == originalNumber;
    }
}

Explanation

• The program takes a lower and upper bound for the range.
• The isArmstrong function checks each number in the given range to see if it is an Armstrong number.
• The program loops through the range and prints all Armstrong numbers found.

Time Complexity: The time complexity for this solution is O(n * d), where n is the number of integers in the range and d is the number of digits in the largest number in the range. For each number, we calculate the sum of the digits raised to the power of the number of digits.

Space Complexity: The space complexity is O(1), as we only use a few variables and don't need additional memory proportional to the input size.

2. Armstrong Number for n-Digit Numbers

To handle Armstrong numbers for n-digit numbers, we can extend the logic to any number of digits by calculating the sum of the digits raised to the power of n (the number of digits in the number). Here’s a general approach:

Java Code

import java.util.Scanner;

public class ArmstrongNDigits {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int num = sc.nextInt();
        
        // Find the number of digits in the number
        int digits = String.valueOf(num).length();
        
        // Check if the number is an Armstrong number
        if (isArmstrong(num, digits)) {
            System.out.println(num + " is an Armstrong number.");
        } else {
            System.out.println(num + " is not an Armstrong number.");
        }
    }

    /
    public static boolean isArmstrong(int num, int digits) {
        int sum = 0;
        int originalNumber = num;

        while (num != 0) {
            int digit = num % 10;
            sum += Math.pow(digit, digits);
            num /= 10;
        }

        return sum == originalNumber;
    }
}

Output

Enter a number: 153
153 is an Armstrong number.

Explanation

• The number of digits is calculated dynamically using String.valueOf(num).length().
• The isArmstrong method checks if the sum of the digits raised to the power of n equals the number itself.

Algorithm to Find the nth Armstrong Number

To determine the nth Armstrong number, we can loop through all natural numbers, verify if each one is an Armstrong number, and count them until we reach the desired nth Armstrong number Here’s how we can implement it:

Java Code

public class NthArmstrongNumber {
    public static void main(String[] args) {
        int n = 5;  // Find the 5th Armstrong number
        int count = 0;
        int num = 0;

        while (count < n) {
            if (isArmstrong(num)) {
                count++;
                if (count == n) {
                    System.out.println("The " + n + "th Armstrong number is: " + num);
                }
            }
            num++;
        }
    }

    /
    public static boolean isArmstrong(int num) {
        int sum = 0;
        int originalNumber = num;
        int digits = String.valueOf(num).length();

        while (num != 0) {
            int digit = num % 10;
            sum += Math.pow(digit, digits);
            num /= 10;
        }

        return sum == originalNumber;
    }
}

Output

The 5th Armstrong number is: 4

Explanation

This Java program finds the nth Armstrong number. IA while loop is used to check numbers beginning from 0. For each number, the isArmstrong(num) method checks if the number is an Armstrong number by summing its digits raised to the power of the number of digits. Once the nth Armstrong number is found, it is printed.

A modular approach involves breaking down a problem into smaller, reusable functions. This approach is particularly useful for programs like Armstrong number checks where we need to perform specific tasks multiple times (such as checking whether a number is an Armstrong number or calculating powers of digits). Below, we outline how we can implement this using functions in Java.

Functions to Check for Armstrong Numbers and Calculate Power of Digits

Function to Check if a Number is an Armstrong Number: The main objective is to determine if a number is an Armstrong number by computing the sum of its digits, each raised to the power of the total number of digits, and comparing this sum with the original number.

Function to Calculate the Power of a Digit: We can create a separate function to calculate the power of a digit. This modular approach ensures that we avoid repeating code and can reuse the power function across different programs.

Java Code

import java.util.Scanner;

public class ArmstrongFunctions {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int num = sc.nextInt();
        
        // Find the number of digits
        int digits = getNumberOfDigits(num);

        // Check if the number is an Armstrong number
        if (isArmstrong(num, digits)) {
            System.out.println(num + " is an Armstrong number.");
        } else {
            System.out.println(num + " is not an Armstrong number.");
        }
    }

    public static int getNumberOfDigits(int num) {
        return String.valueOf(num).length();
    }

       public static boolean isArmstrong(int num, int digits) {
        int sum = 0;
        int originalNumber = num;

        while (num != 0) {
            int digit = num % 10;
            sum += power(digit, digits); // Use the power function to raise digits to the power of 'digits'
            num /= 10;
        }

        return sum == originalNumber;
    }

    public static int power(int base, int exponent) {
        return (int) Math.pow(base, exponent);
    }
}

Output

Enter a number: 153
153 is an Armstrong number.

Explanation

• This function returns the number of digits in the number by converting the number to a string and measuring its length.
• This function checks if the given number is an Armstrong number by iterating through each digit, raising it to the power of the total number of digits, and summing up the results.
• A helper function to calculate the power of a digit.

Here are the common errors and best practices for Armstrong number:

Errors to Avoid

• Ensure that the formula for an Armstrong number is correctly understood: the sum of the digits raised to the power of the number of digits should be equal to the original number.
• Be cautious when defining the range of numbers to check. For example, incorrectly setting the boundaries could lead to missed Armstrong numbers or unnecessary checks.

Best Practices

• Break the problem into functions like isArmstrong(), power(), and getNumberOfDigits(). This improves readability and reusability.
• Test with edge cases, such as:
  
  • Numbers like 0 and 1, which are Armstrong numbers by definition.
  • Very large numbers, where computational limits might affect performance.
  • Ranges where no Armstrong numbers exist (like 2-digit ranges).

The time and space complexities analysis using different methods for armstrong number:

Time Complexity: Analysis of Different Methods

1. Naive Method:

• Time Complexity: The naive method has a time complexity of O(d) for each number, where d is the number of digits in the number. If we are checking a range of numbers, the overall time complexity is O(n * d), where n is the size of the range.

2. Optimized Approach:

• Time Complexity: In optimized methods where we avoid redundant calculations (such as recalculating powers of digits), the time complexity could be reduced, but it still generally remains O(n * d) due to the need to check each number in the range.
• Space Complexity: Memory Usage in Basic and Recursive Approaches

3. Basic Approach:

• Space Complexity: The space complexity for the basic approach is O(1), as we only use a few variables to store the sum, original number, and digit count.

4. Recursive Approach:

• Space Complexity: If recursion is used (e.g., to calculate the power of digits), the space complexity increases to O(d), as each recursive call adds to the stack. However, for small ranges and numbers, this is not significant.

In competitive programming, Armstrong numbers are a common problem type that often tests your understanding of loops, recursion, and number theory. These types of problems challenge participants to implement efficient solutions for checking if a given number is an Armstrong number or not.

Why Armstrong Numbers are a Popular Problem in Coding Interviews?

In coding interviews, Armstrong number problems test the candidate's ability to:

• Implement basic algorithms.
• Use loops and conditionals effectively.
• Handle number manipulations such as powers and digit extraction.

Tips to Optimize Armstrong Number Programs for Competitions

Here are the tips to optimize Armstrong number program in Java for competitions:

• Use techniques like memoization or caching to store results of repeated computations.
• Avoid unnecessary loops or nested loops where possible.
• Ensure edge cases (such as single-digit numbers or large numbers) are handled correctly and efficiently.
• Be aware of how the complexity of your solution will affect performance for larger inputs, especially for competitive programming problems with large constraints.

In conclusion, Armstrong numbers in Java, covering their definition, significance, and various methods to check for them, including naive and advanced approaches like recursion and string manipulation. We discussed handling Armstrong numbers across different digit lengths, using modular functions for efficiency, and optimizing programs for large ranges. Additionally, we analyzed the time and space complexity of different methods and provided best practices to avoid common errors. Understanding Armstrong numbers is crucial for Java beginners as it enhances problem-solving skills and prepares you for coding interviews and competitive programming challenges.

1. How do I check if a number is an Armstrong number in Java?

To check if a number is an Armstrong number in Java, calculate the sum of each digit raised to the power of the number of digits in the number and compare it with the original number. If the sum matches the original number, it is considered an Armstrong number.

2. Can I use recursion to check Armstrong numbers in Java?

Yes, you can use recursion to solve the problem by breaking it into smaller tasks, such as calculating the sum of the digits raised to the power of the number of digits. A recursive function can be written to handle this process.

3. How do I find Armstrong numbers in a range in Java?

You can write a Java program that checks all numbers in a specified range and determines if they are Armstrong numbers. This involves iterating through the range and applying the Armstrong check logic for each number.

4. Why are there no 2-digit Armstrong numbers?

2-digit Armstrong numbers do not exist because the sum of the digits raised to the power of 2 (the number of digits) cannot form a 2-digit number. The values do not satisfy the Armstrong condition for 2-digit numbers.

5. What is the time complexity of checking Armstrong numbers?

The time complexity of checking if a number is an Armstrong number is O(d), where d is the number of digits in the number. For a range of numbers, the time complexity becomes O(n * d), where n is the number of numbers being checked and d is the number of digits in each number.