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 string scan.
Require a positive integer (n > 0).
Count the digits (or convert to a string).
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
String scan
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 std::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 string scan 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 <iostream>
int intPow(int baseValue, int exp) {
int result = 1;
for (int i = 0; i < exp; i++) {
result *= baseValue;
}
return result;
}
int countDigits(int n) {
int count = 0;
while (n > 0) {
count++;
n /= 10;
}
return count;
}
bool isDisarium(int n) {
if (n <= 0) {
return false;
}
int power = countDigits(n);
int sum = 0;
int temp = n;
while (temp > 0) {
int digit = temp % 10;
sum += intPow(digit, power);
power--;
temp /= 10;
}
return sum == n;
}
int main() {
int number = 135;
std::cout << number
<< (isDisarium(number) ? " is Disarium\n" : " is not Disarium\n");
return 0;
}
Output
135 is Disarium
How It Works
intPow multiplies in a loop so powers stay exact integers (no std::pow doubles).
countDigits 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 — String Scan
Convert to a string so index i maps directly to power i + 1.
C++
#include <iostream>
#include <string>
int intPow(int baseValue, int exp) {
int result = 1;
for (int i = 0; i < exp; i++) {
result *= baseValue;
}
return result;
}
bool isDisarium(int n) {
if (n <= 0) {
return false;
}
std::string s = std::to_string(n);
int sum = 0;
for (std::size_t i = 0; i < s.size(); i++) {
int digit = s[i] - '0';
int power = static_cast<int>(i) + 1;
sum += intPow(digit, power);
}
return sum == n;
}
int main() {
std::cout << std::boolalpha;
std::cout << isDisarium(89) << "\n"; // true
std::cout << isDisarium(90) << "\n"; // false
std::cout << isDisarium(135) << "\n"; // true
return 0;
}
Output
true
false
true
How It Works
std::to_string(n) gives 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 intPow 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.
std::pow
Prefer intPow
std::pow 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)
String scan
O(d²)
O(d) for the string
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.
