A positive integer is a Disarium number when the sum of its digits, each raised to the power of its left-to-right position (starting at 1), equals the number itself.
Four clear steps — then pick a right-to-left peel or a left-to-right digit buffer.
Require a positive integer (n > 0).
Count the digits (or write them into a buffer).
Raise each digit to its position power and add the results.
Compare the sum with the original n.
Method
Idea
Time
Best for
Right-to-left peel
Start power at digit count; decrease while peeling
O(d²)
Interviews without strings
Digit buffer
Index i maps to power i + 1
O(d²)
Clear left-to-right reasoning
Pseudocode
Pseudocode
function IsDisarium(n):
if n <= 0: return false
digits = countDigits(n)
sum = 0
temp = n
power = digits
while temp > 0:
digit = temp mod 10
sum = sum + digit ^ power
power = power - 1
temp = temp / 10
return sum == n
Reference
Cheat Sheet
Keep these facts handy while writing the program.
Topic
Detail
Position
Leftmost digit has power 1
vs Armstrong
Armstrong uses one shared exponent (digit count)
One digit
1–9 are all Disarium
Classic checks
89, 135
Power helper
Prefer integer multiply over pow()
Zero / negatives
Treat as not Disarium in this tutorial
Try it
Live Preview
Enter a positive integer to see each digitposition term and the final check.
Positive integers only. Tap a chip or type a value.
Result
n = 135
1^1 + 3^2 + 5^3 = 1 + 9 + 125 = 135
135 is a Disarium number
Trace
Worked Walkthrough — n = 135
Three digits → powers 1, 2, and 3 from left to right.
Calculation
Digits: 1, 3, 5 (count = 3)
1¹ = 1
3² = 9
5³ = 125
Sum = 1 + 9 + 125 = 135
135 == 135 → Disarium
Right-to-left peel (same powers):
peel 5 with power 3 → 125
peel 3 with power 2 → 9
peel 1 with power 1 → 1
Code
C Programs
Start with the integer peel so you can explain every power without strings. Then use a digit buffer when left-to-right indexing feels clearer.
Example 1 — Right-to-Left Peel
Count digits, then peel from the right while decreasing the position power.
C
#include <stdio.h>
int int_pow(int base, int exp)
{
int result = 1;
int i;
for (i = 0; i < exp; i++)
{
result *= base;
}
return result;
}
int count_digits(int n)
{
int count = 0;
while (n > 0)
{
count++;
n /= 10;
}
return count;
}
int is_disarium(int n)
{
int power;
int sum = 0;
int temp;
if (n <= 0)
{
return 0;
}
power = count_digits(n);
temp = n;
while (temp > 0)
{
int digit = temp % 10;
sum += int_pow(digit, power);
power--;
temp /= 10;
}
return sum == n;
}
int main(void)
{
int number = 135;
if (is_disarium(number))
printf("%d is Disarium\n", number);
else
printf("%d is not Disarium\n", number);
return 0;
}
Output
135 is Disarium
How It Works
int_pow multiplies in a loop so powers stay exact integers (no pow() doubles).
count_digits finds how many positions exist — that becomes the starting power.
Reject non-positive inputs; this page defines Disarium for positive integers only.
Each temp % 10 peels the next rightmost digit; power-- keeps positions correct.
Compare sum == n. For 135: 5³ + 3² + 1¹ = 125 + 9 + 1 = 135.
Example 2 — Digit Buffer
Write digits into a char buffer so index i maps directly to power i + 1.
C
#include <stdio.h>
int int_pow(int base, int exp)
{
int result = 1;
int i;
for (i = 0; i < exp; i++)
{
result *= base;
}
return result;
}
int is_disarium(int n)
{
char s[16];
int i;
int sum = 0;
int len;
if (n <= 0)
{
return 0;
}
len = sprintf(s, "%d", n);
for (i = 0; i < len; i++)
{
int digit = s[i] - '0';
int power = i + 1;
sum += int_pow(digit, power);
}
return sum == n;
}
int main(void)
{
printf("%s\n", is_disarium(89) ? "1" : "0"); /* 1 */
printf("%s\n", is_disarium(90) ? "1" : "0"); /* 0 */
printf("%s\n", is_disarium(135) ? "1" : "0"); /* 1 */
return 0;
}
Output
1
0
1
How It Works
sprintf(s, "%d", n) writes digits in left-to-right order.
Index 0 is position 1, so power is always i + 1.
s[i] - '0' converts a digit character to an integer.
Same int_pow helper keeps results exact.
Answers match Example 1; pick the style that is easier to explain in the interview.
Edge Cases & Pitfalls
Check these before calling the solution done.
1–9
Single digits
All of 1 through 9 pass because d¹ = d.
Powers
Not all cubes
Each digit gets its own position power — unlike Armstrong.
pow()
Prefer int_pow
pow() from math.h returns double; keep integer multiply for exactness.
≤ 0
Not Disarium here
This tutorial requires a positive integer.
Analysis
Time and Space Complexity
Program
Time
Extra space
Right-to-left peel
O(d²)
O(1)
Digit buffer
O(d²)
O(d) for the buffer
Here d is the digit count. Each power costs up to O(d) multiplies, and there are d digits.
Remember
Key Takeaways
Definition: digitposition sum equals n (positions from the left).
Peel trick: start power at digit count and decrease while peeling right.
vs Armstrong: Disarium uses different powers per digit.
Test set: 7 → yes; 89 → yes; 135 → yes; 90 → no.
One line: raise each digit to its left-to-right position and compare the sum with n.
Frequently Asked Questions
A positive integer n is Disarium if the sum of its digits, each raised to the power of its left-to-right position (starting at 1), equals n. Example: 89 = 8¹ + 9².
Armstrong raises every digit to the same power (the digit count). Disarium raises each digit to its own position index from the left.
n % 10 and n / 10 are simple. Start the exponent at the digit count and decrease it so powers still match left-to-right positions.
Yes for 1 through 9, because d¹ = d. Zero is usually excluded when the definition requires a positive integer.
For d digits, a straightforward check with an integer power helper is O(d²) time and O(1) extra space for the peel method.
