An Armstrong number (also called a narcissistic number) equals the sum of its digits, each raised to the power of the digit count.
Remember
n is Armstrong ↔ n = sum of (each digit ^ k)
where k = number of digits in n
Example: 153 (k = 3)
1³ + 5³ + 3³ = 1 + 125 + 27 = 153
Also: 1–9 (one digit), 370, 371, 407
n
Digit powers
Result
153
1³+5³+3³ = 153
Armstrong
370
3³+7³+0³ = 370
Armstrong
123
1³+2³+3³ = 36
Not Armstrong
5
5¹ = 5
Armstrong
Approach
How to Check an Armstrong Number in Python
Four clear steps — count digits first, then sum powers with that same exponent.
Reject n <= 0 for this page’s positive-integer rule.
Count digits into k (repeatedly divide by 10 with //).
Peel each digit with % 10 and add digit ** k.
Compare the sum with the original number.
Method
Idea
Time
Best for
Digit loop + **
Count k, then sum d ** k
O(log n)
Interviews, default
Power table
Precompute 0^k..9^k
O(log n)
Many checks with same k
Range scan
Reuse the helper
O(N log N)
Listing Armstrong numbers
Pseudocode
Pseudocode
function IsArmstrong(n):
if n <= 0:
return false
k = digitCount(n)
sum = 0
t = n
while t > 0:
d = t mod 10
sum = sum + (d ^ k)
t = t / 10
return sum == n
Reference
Cheat Sheet
Keep these facts handy while writing the program.
Topic
Detail
Test
sum(digit ** k) == n, k = digits
Peel digit
d = n % 10, then n = n // 10
Powers
Use integer **, not math.pow
1 digit
1–9 are Armstrong
3 digits
153, 370, 371, 407
1..200
1–9 and 153
Try it
Live Preview
Enter a positive integer to see each digit power and the Armstrong verdict.
Positive whole numbers. Tap a chip or type a value.
Start with a single check using integer powers. Then list a range, and finish with a digit-power lookup table.
Example 1 — Check One Number
Count digits, sum d ** k for each digit, then compare with the original value.
Python
def is_armstrong(number):
if number <= 0:
return False
k = 0
t = number
while t > 0:
k += 1
t //= 10
total = 0
t = number
while t > 0:
d = t % 10
total += d ** k
t //= 10
return total == number
number = 153
if is_armstrong(number):
print(f"{number} is an Armstrong number.")
else:
print(f"{number} is not an Armstrong number.")
Output
153 is an Armstrong number.
How It Works
Return False for non-positive inputs.
Count digits into k with a working copy t and integer division //=.
Peel digits again and add d ** k each time.
Compare total with the original number.
Integer ** stays exact — avoid floating math.pow.
Example 2 — Armstrong Numbers from 1 to 200
Reuse the helper and print every match in a closed range.
Python
def is_armstrong(num):
if num <= 0:
return False
k = 0
t = num
while t > 0:
k += 1
t //= 10
total = 0
t = num
while t > 0:
d = t % 10
total += d ** k
t //= 10
return total == num
start = 1
end = 200
print(f"Armstrong numbers in the range {start} to {end}:")
line = ""
for i in range(start, end + 1):
if is_armstrong(i):
line += str(i) + " "
print(line.strip())
Output
Armstrong numbers in the range 1 to 200:
1 2 3 4 5 6 7 8 9 153
How It Works
Loop from start to end inclusive with range(start, end + 1).
Call is_armstrong(i) for each value.
Single-digit numbers print first (each is Armstrong).
153 is the only other hit in 1…200.
The helper stays pure; the loop only decides what to print.
Example 3 — Digit-Power Lookup Table
Build 0^k … 9^k once, then sum with list lookups.
Python
def is_armstrong(number):
if number <= 0:
return False
k = 0
t = number
while t > 0:
k += 1
t //= 10
pows = [i ** k for i in range(10)]
total = 0
t = number
while t > 0:
total += pows[t % 10]
t //= 10
return total == number
print(is_armstrong(153)) # True
print(is_armstrong(123)) # False
Output
True
False
How It Works
Count digits into k as before.
Fill pows[0..9] with i ** k once using a list comprehension.
Each digit then costs a list lookup instead of a fresh power.
153 prints True; 123 prints False.
Useful when scanning many numbers that share the same digit length.
Edge Cases & Pitfalls
Check these before calling the solution done.
Exponent
Use digit count k
Do not hard-code cubes unless the problem is only about 3-digit numbers.
math.pow
Prefer integer **
Floating math.pow can round wrong. Use integer ** for exact equality.
Zero
Definitions vary
This page returns False for n <= 0. Follow the problem statement if it includes 0.
Division
Use //
Always peel digits with // 10, not / 10, so you stay in integers.
Analysis
Time and Space Complexity
Program
Time
Extra space
Single check
O(log n)
O(1)
Range of size N
O(N log N)
O(1)
Power table check
O(log n)
O(1) (10 slots)
Digit count d is about log₁₀ n. Each power costs O(d) with a simple loop, still fine for interviews.
Remember
Key Takeaways
Definition: sum of each digit raised to the digit count equals n.
Test set: 153 and 9 yes; 123 no; 1..200 → 1–9 and 153.
One line: raise each digit to the digit count and see if the sum rebuilds the number.
Frequently Asked Questions
A positive integer n is Armstrong (narcissistic) if it equals the sum of its digits, each raised to the power of the digit count. Example: 153 has 3 digits and 1³ + 5³ + 3³ = 153.
Yes. For a one-digit n, the count is 1 and n¹ = n. This page treats n <= 0 as not Armstrong.
For integers, ** stays exact. math.pow returns a float and can round incorrectly for larger values.
The same k for every digit, where k is the number of digits in n. Do not hard-code cubes unless you only care about 3-digit cases.
Counting digits and summing powers are both O(d), and d is about log₁₀ n, so one check is O(log n).
