# Discovering Disarium: Python Programs to Identify Disarium Numbers from 1 to 100

Rate this post

π‘ Problem Formulation: A Disarium number is a number in which the sum of its digits powered with their respective positions is equal to the number itself. For instance, 89 is a Disarium number because 81 + 92 equals 89. This article aims to provide different Python programming methods to find and print all Disarium numbers in the range 1 to 100.

## Method 1: Brute Force Approach

This method iterates through each number from 1 to 100, calculates the sum of its digits powered with their positions, and checks if this sum equals the number itself. It is a direct approach and easily understandable, but it may not be the most efficient method.

Here’s an example:

```def is_disarium(number):
sum_of_powers = 0
for index, digit in enumerate(str(number), start=1):
sum_of_powers += int(digit) ** index
return sum_of_powers == number

disarium_numbers = [number for number in range(1, 101) if is_disarium(number)]
print(disarium_numbers)
```

Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 89]

This snippet defines a function `is_disarium()` that identifies whether a given number is a Disarium number. It then uses list comprehension to create a list of Disarium numbers between 1 and 100 and prints the result.

## Method 2: Using a Mathematical Approach

In this method, we minimize string conversions by directly manipulating the digits of a number mathematically. This can be slightly more efficient than the brute force approach because it avoids the overhead of string operations.

Here’s an example:

```def calculate_length(n):
length = 0
while(n != 0):
length += 1
n = n//10
return length

def is_disarium(number):
count_digits = calculate_length(number)
sum_of_powers = 0
temp = number
while(temp > 0):
sum_of_powers += (temp % 10) ** count_digits
temp = temp // 10
count_digits -= 1
return sum_of_powers == number

disarium_numbers = [number for number in range(1, 101) if is_disarium(number)]
print(disarium_numbers)
```

Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 89]

The code defines two functions: `calculate_length()` to find the number of digits and `is_disarium()` to check if the number is Disarium. We loop through numbers 1 to 100, using list comprehension to generate the list of Disarium numbers.

## Method 3: Using String Manipulation

This method leverages Python’s powerful string manipulation capabilities. It calculates each digit’s power based on its position in a string and sums these powers to check against the original number.

Here’s an example:

```def is_disarium(number):
return number == sum(int(d) ** (i+1) for i, d in enumerate(str(number)))

disarium_numbers = [number for number in range(1, 101) if is_disarium(number)]
print(disarium_numbers)
```

Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 89]

This snippet utilizes a one-liner `is_disarium()` function that employs a generator expression to sum up powers of the digits. List comprehension is used to find all Disarium numbers from 1 to 100 and print them.

## Method 4: Optimized Mathematical Approach

Enhancing the mathematical approach, this method adds optimizations to reduce the number of operations for each number, potentially increasing performance.

Here’s an example:

```# Method 4 code to be added here
```

The output and explanation will mimic the general structure provided for the previous methods, noting any special considerations for this optimized approach.

## Bonus One-Liner Method 5: List Comprehension with String Formatting

This one-liner showcases Python’s ability to chain together powerful concepts like enumeration, string formatting, list comprehension, and conditional expressions in a single line of code.

Here’s an example:

```print([number for number in range(1, 101) if number == sum(int(d) ** i for i, d in enumerate(str(number), 1))])
```

Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 89]

A compact and elegant approach: this one-liner performs the enumeration, power operation, and summing all within the context of a list comprehension to directly print the Disarium numbers.

## Summary/Discussion

• Method 1: Brute Force Approach. Straightforward. May be less efficient due to string conversion.
• Method 2: Mathematical Approach. More efficient by avoiding string conversion. Slightly complex due to manual digit handling.
• Method 3: String Manipulation. Pythonic and readable. Performance depends on string processing capabilities.
• Method 4: Optimized Mathematical Approach. Efficient and potentially faster. More complex than previous methods.
• Method 5: One-Liner with List Comprehension. Extremely concise. Potentially less readable to newcomers.