Armstrong Number - Practice Coding Problems

Armstrong Number - Problem

Math Easy

An Armstrong number (also known as a narcissistic number or pluperfect digital invariant) is a fascinating mathematical curiosity that equals the sum of its own digits each raised to the power of the number of digits.

More formally: A k-digit number n is an Armstrong number if and only if the k-th power of each digit sums to n.

Examples:

153 is a 3-digit Armstrong number: 1³ + 5³ + 3³ = 1 + 125 + 27 = 153 ✓
9474 is a 4-digit Armstrong number: 9⁴ + 4⁴ + 7⁴ + 4⁴ = 6561 + 256 + 2401 + 256 = 9474 ✓
123 is NOT an Armstrong number: 1³ + 2³ + 3³ = 1 + 8 + 27 = 36 ≠ 123 ✗

Given an integer n, return true if it's an Armstrong number, false otherwise.

Input & Output

example_1.py — Simple 3-digit Armstrong

$ Input: 153

› Output: true

💡 Note: 153 is a 3-digit number. 1³ + 5³ + 3³ = 1 + 125 + 27 = 153, which equals the original number.

example_2.py — Single digit (always Armstrong)

$ Input: 5

› Output: true

💡 Note: 5 is a 1-digit number. 5¹ = 5, which equals the original number. All single digits are Armstrong numbers.

example_3.py — Not an Armstrong number

$ Input: 123

› Output: false

💡 Note: 123 is a 3-digit number. 1³ + 2³ + 3³ = 1 + 8 + 27 = 36 ≠ 123, so it's not an Armstrong number.

Constraints

0 ≤ n ≤ 10⁸
The input will always be a non-negative integer
Note: All single-digit numbers (0-9) are Armstrong numbers

Visualization

Tap to expand

Understanding the Visualization

Count the Evidence

Count how many digits the suspect number has - this becomes our power

Extract Each Clue

Extract each digit one by one using mathematical operations

Calculate Powers

Raise each digit to the power equal to the total digit count

Sum the Evidence

Add up all the calculated powers

Make the Verdict

Compare the sum with the original number - if equal, it's an Armstrong number!

Key Takeaway

🎯 Key Insight: Armstrong numbers are mathematical gems where the sum of digits raised to the power of digit count equals the original number. Use modulo arithmetic for efficient digit extraction!

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 6

The optimal approach uses mathematical operations to extract digits via modulo and division, avoiding string conversion overhead. Count digits first, then calculate the sum of each digit raised to the k-th power where k is the total number of digits. Time complexity: O(d) where d is the number of digits.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Approach (Optimal)	O(d)	O(1)	Use mathematical operations to extract digits without string conversion
String Conversion Approach	O(d)	O(d)	Convert number to string, iterate through characters, and calculate sum

Mathematical Approach (Optimal) — Algorithm Steps

Count digits by repeatedly dividing by 10
Extract digits using modulo 10 operation
Raise each digit to the power of total digit count
Accumulate sum while processing each digit
Compare final sum with original number

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Digits

153 → 15 → 1 → 0 (3 divisions = 3 digits)

Extract & Calculate

153 % 10 = 3, 3³ = 27

Continue Extraction

15 % 10 = 5, 5³ = 125

Final Digit

1 % 10 = 1, 1³ = 1

Sum & Compare

27 + 125 + 1 = 153 ✓

Code -

solution.c — C

#include <stdio.h>
#include <math.h>

int isArmstrong(int n) {
    if (n < 0) return 0;
    
    int original = n;
    
    // Count digits
    int temp = n;
    int numDigits = 0;
    while (temp > 0) {
        numDigits++;
        temp /= 10;
    }
    
    // Handle edge case of 0
    if (original == 0) {
        numDigits = 1;
    }
    
    // Calculate sum of powers
    int digitSum = 0;
    temp = original;
    while (temp > 0) {
        int digit = temp % 10;
        digitSum += pow(digit, numDigits);
        temp /= 10;
    }
    
    return digitSum == original;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%s\n", isArmstrong(n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(d)

Where d is the number of digits. We process each digit twice: once for counting, once for calculation.

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables.

✓ Linear Space

42.0K Views

Medium Frequency

~15 min Avg. Time

1.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Mathematical Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler