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

by

💡 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.