Write a program to check Armstrong number.

Armstrong Numbers: A Deep Dive with Python, Java, and C++

I. Introduction

Dive into the fascinating world of Armstrong numbers, where mathematics meets elegant programming solutions! An Armstrong number (also known as a narcissistic number) is a number that is equal to the sum of its own digits raised to the power of the number of digits. For example, 153 is an Armstrong number because 1³ + 5³ + 3³ = 1 + 125 + 27 = 153. This blog post will explain the concept of Armstrong numbers and provide code implementations in Python, Java, and C++ to check if a given number is an Armstrong number.

II. Understanding the Logic

Let's break down how to determine if a number is an Armstrong number:

1. Extract Digits: Separate the number into its individual digits (e.g., 153 becomes 1, 5, 3).
2. Raise to Power: Raise each digit to the power of the total number of digits (in this case, 3).
3. Sum of Powers: Add up the results from step 2 (1³ + 5³ + 3³).
4. Comparison: Compare the sum to the original number. If they are equal, it's an Armstrong number!

Illustrative Example (153):

1. Digits: 1, 5, 3
2. Powers: 1³, 5³, 3³ = 1, 125, 27
3. Sum: 1 + 125 + 27 = 153
4. Comparison: 153 == 153 (True) - Therefore, 153 is an Armstrong number.

III. Python Code Implementation

def isArmstrong(num):
    num_str = str(num)
    num_digits = len(num_str)
    sum_of_powers = 0
    for digit in num_str:
        sum_of_powers += int(digit) ** num_digits
    return sum_of_powers == num

print(isArmstrong(153))  # Output: True
print(isArmstrong(370))  # Output: True
print(isArmstrong(123))  # Output: False

This Python function converts the number to a string, extracts each digit, raises it to the power of the number of digits, and sums the results. Finally, it compares the sum to the original number.

IV. Java Code Implementation

class ArmstrongChecker {
    public static boolean isArmstrong(int num) {
        String numStr = Integer.toString(num);
        int numDigits = numStr.length();
        int sumOfPowers = 0;
        for (int i = 0; i < numDigits; i++) {
            int digit = Character.getNumericValue(numStr.charAt(i));
            sumOfPowers += Math.pow(digit, numDigits);
        }
        return sumOfPowers == num;
    }
    public static void main(String[] args){
        System.out.println(isArmstrong(153)); //true
        System.out.println(isArmstrong(371)); //true
        System.out.println(isArmstrong(123)); //false
    }
}

The Java implementation mirrors the Python version, utilizing string manipulation for digit extraction and Math.pow() for exponentiation.

V. C++ Code Implementation

#include <iostream>
#include <string>
#include <cmath>

using namespace std;

bool isArmstrong(int num) {
    string numStr = to_string(num);
    int numDigits = numStr.length();
    int sumOfPowers = 0;
    for (char digitChar : numStr) {
        int digit = digitChar - '0';
        sumOfPowers += pow(digit, numDigits);
    }
    return sumOfPowers == num;
}

int main() {
    cout << isArmstrong(153) << endl; // Output: 1
    cout << isArmstrong(370) << endl; // Output: 1
    cout << isArmstrong(123) << endl; // Output: 0
    return 0;
}

The C++ code uses similar logic, employing string streams for digit extraction and the cmath library's pow() function.

VI. Conclusion

We've explored Armstrong numbers, understood their logic, and implemented detection functions in Python, Java, and C++. This provides a solid foundation for further exploration into number theory and programming challenges. You can further explore other number properties, or try optimizing these functions for larger numbers!

VII. FAQs

Q: What happens if a number has leading zeros?
A: Leading zeros should be ignored, as they don't affect the value.

Q: Are there infinite Armstrong numbers?
A: It's an open question in mathematics whether there are infinitely many Armstrong numbers.