Armstrong Number

class Solution {
public:
    int sumDigitPowers(int number, int power) {
        int sum = 0;
        while(number != 0) {
            sum += pow(number % 10, power);
            number /= 10;
        }
        return sum;
    }
    bool isArmstrongNumber(int number) {
        int digits = 0;
        int temp = number;
        while (temp) {
            digits++;
            temp /= 10;
        }
        return sumDigitPowers(number, digits) == number;
    }
};

The given C++ code defines a solution for checking whether a number is an Armstrong number. An Armstrong number, also known as a narcissistic number, is a number that is the sum of its own digits each raised to the power of the number of digits.

The implementation is provided within a class named Solution which includes two functions:

• sumDigitPowers(int number, int power): This function calculates the sum of each digit in the number raised to a specified power. It uses a loop to process each digit of the input number. The digit is obtained using number % 10, and it's raised to the specified power using pow(number % 10, power). The loop continues until all digits are processed (i.e., number becomes 0).

• isArmstrongNumber(int number): This function first determines the number of digits in the input number. It then calls sumDigitPowers with the number and its digit count as arguments to compute the required sum, and checks if this sum is equal to the original number.

By using these functions, you can verify if a given integer is an Armstrong number by seeing if the sum of its digits, each raised to the power of the count of digits in the number, matches the original number. This approach uses basic loop and arithmetic operations, providing a clear and direct method to solve the problem.

class Solution {
    public int sumOfKthPowers(int num, int power) {
        // Calculating sum of kth power of digits
        int total = 0;
        while(num != 0) {
            total += Math.pow(num % 10, power);
            num /= 10;
        }
        return total;
    }
    public boolean isArmstrongNumber(int value) {
        // Determining the number of digits
        int digits = 0;
        int copyOfValue = value;
        while (copyOfValue != 0) {
            digits++;
            copyOfValue /= 10;
        }
        // Check if it's an Armstrong number
        return sumOfKthPowers(value, digits) == value;
    }
}

The provided Java program checks if a number is an Armstrong number. An Armstrong number is one that is equal to the sum of its digits each raised to the power of the number of digits. The Solution class contains two methods:

• sumOfKthPowers(int num, int power): This method computes the sum of each digit of the given number num raised to the specified power. It iterates through each digit, calculates the power using Math.pow, and accumulates the result to get the total.

• isArmstrongNumber(int value): This method determines if value is an Armstrong number. It first calculates the number of digits in value. It uses sumOfKthPowers to compute the sum of each digit of value raised to the number of digits. It then checks if this sum is equal to value, returning true if it matches, and false otherwise.

Use this program to verify if a number meets the Armstrong condition by instantiating Solution and calling the isArmstrongNumber method with the desired number as its argument.