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 Math.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#
using System;
class Program
{
static int IntPow(int baseValue, int exp)
{
int result = 1;
for (int i = 0; i < exp; i++)
{
result *= baseValue;
}
return result;
}
static int CountDigits(int n)
{
int count = 0;
while (n > 0)
{
count++;
n /= 10;
}
return count;
}
static 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;
}
static void Main()
{
int number = 135;
Console.WriteLine(number + (IsDisarium(number) ? " is Disarium" : " is not Disarium"));
}
}
Output
135 is Disarium
How It Works
IntPow multiplies in a loop so powers stay exact integers (no Math.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#
using System;
class Program
{
static int IntPow(int baseValue, int exp)
{
int result = 1;
for (int i = 0; i < exp; i++)
{
result *= baseValue;
}
return result;
}
static bool IsDisarium(int n)
{
if (n <= 0)
{
return false;
}
string s = n.ToString();
int sum = 0;
for (int i = 0; i < s.Length; i++)
{
int digit = s[i] - '0';
int power = i + 1;
sum += IntPow(digit, power);
}
return sum == n;
}
static void Main()
{
Console.WriteLine(IsDisarium(89)); // True
Console.WriteLine(IsDisarium(90)); // False
Console.WriteLine(IsDisarium(135)); // True
}
}
Output
True
False
True
How It Works
n.ToString() 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.
Math.Pow
Prefer IntPow
Math.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.
