## Introduction to Disarium Number

Mathematics is a fascinating field, with various anomalies and patterns to ponder over. For instance, have you ever heard of Disarium Numbers?

Before we delve into what a Disarium Number is, let’s take a moment to understand what the term “disarium” means. Disarium is derived from the latin word “dis” and “arium,” which means apart and a collection or category, respectively.

Simply put, Disarium refers to a set of numbers that are different or apart from the rest.

## Definition of Disarium Number

A Disarium Number is a number that satisfies the following criteria. If the sum of the digits of the number raised to the power of their respective positions equals the number itself, it is a Disarium Number.

This might sound complicated, but let’s break it down. For instance, if we take 135, we can break it down into its digits 1, 3, and 5.

The sum of these digits raised to their respective powers is 1^1 + 3^2 + 5^3, which equals 135. Therefore, 135 is a Disarium Number.

## Examples of Disarium Number

Now that we have a basic understanding of what a Disarium Number is, let’s take a look at some examples. Here are a few Disarium Numbers: 175, 89, and 518.

In 175, the sum of the digits raised to their respective powers is 1^1 + 7^2 + 5^3, which equals 175. Therefore, 175 is a Disarium Number.

In the number 89, the sum of the digits raised to their respective powers is 8^1 + 9^2, which equals 89. Therefore, 89 is a Disarium Number.

In the number 518, the sum of the digits raised to their respective powers is 5^1 + 1^2 + 8^3, which equals 518. Therefore, 518 is a Disarium Number.

## Algorithm to check Disarium Number

Now that we have an understanding of what a Disarium Number is and have seen some examples, let’s look at how we can identify whether a number is a Disarium Number. Here’s an algorithm that provides a step-by-step process for checking if a number is a Disarium Number.

- Input a number (n).
- Find the number of digits (d) in the input number (n).
- Initialize the result to zero.
- Store the input number (n) in a temporary variable (temp).
- Repeat the following steps for each digit in the input number (n)
- Extract the last digit (d) of the temporary variable.
- Add the sum of the digit (d) raised to the power of its position (p), where position (p) is the number of digits minus the current index starting from 1 to the result variable.
- Divide the temporary variable by 10 and repeat from Step 6 until no digits remain.
- Compare the input number (n) with the result variable.

If they are equal, n is a Disarium Number.

## PseudoCode for Identifying a Disarium Number

Here’s a PseudoCode example that outlines how to identify a Disarium Number with an input by the user.

### START

### Input n

Set sum = 0

Set temp = n

Set d = Count the number of digits in n

FOR i in range (1, d+1):

Set digit = temp % 10

Set sum = sum + digit**i

Set temp = temp // 10

### END FOR

IF sum == n

DISPLAY “n is a Disarium Number”

### ELSE

DISPLAY “n is not a Disarium Number”

### END IF

### STOP

## Conclusion

Disarium Numbers might not be as popular as other numbers such as perfect numbers or prime numbers, but they have their unique characteristics. We’ve learned that Disarium Numbers are those that satisfy the criteria of adding the sum of the digits raised to their respective powers being equal to the number itself.

We also explored some examples and an algorithm for identifying Disarium Numbers. Hopefully, this article provided you with an insightful introduction into the fascinating world of Disarium Numbers.

## Implementing a Check for Disarium Number in Python

Now that we have learned about what a Disarium Number is and have gone through the algorithm for identifying it, let’s move on to implementation. Implementing Disarium Number check in Python is easy, and we’ll demonstrate how in the following paragraphs.

### Initializing Variables

Before we start traversing through the input number and update the result, we need to initialize some variables.

The first step is to get the input number from the user, so we will use the input() function to allow the user to enter a number.

Next, we need to initialize the result to 0. We will use a variable called “result” and set it to 0.

This variable will store the sum of the digits raised to their respective power based on their positions. Lastly, we need to make a copy of the input number since we will be performing operations on it without changing the original input.

We will use a variable called “temp” and set it to a copy of the input number using the slice operator [:]. Here’s an example:

```
num = input("Enter a number: ")
result = 0
temp = num[:]
```

In the code above, we prompt the user to enter a number and store it in a variable called “num.” We then initialize “result” to 0 and make a copy of the input number using the slice operator [:] and store it in a variable called “temp.”

### Traversing through the Number and Updating Result

The next step is to traverse through the number’s digits and update the “result” variable accordingly. We need to extract each digit, raise it to the corresponding power, and add it to the result.

We can use a while loop to achieve this.

In each iteration of the while loop, we extract the last digit by using the modulus operator (%) and set it to a variable called “digit.” We then raise the “digit” to the power of its corresponding position using the pow() function and add it to the “result” variable.

Finally, we divide the “temp” variable by 10 to remove the extracted digit.

Here’s an example:

```
while temp != 0:
digit = temp % 10
result += pow(digit, len(num))
temp //= 10
```

In the code above, we use a while loop to traverse through the digits in “temp.” We extract the last digit by using the modulus operator (%) and set it to a variable called “digit.” We then raise “digit” to the power of the length of the input number using the pow() function.

We add this result to the “result” variable. Finally, we divide “temp” by 10 to remove the extracted digit.

### Checking if the Number is a Disarium Number or Not

Once we have updated the “result” variable, we need to check if the input number is a Disarium Number or not. To do this, we need to compare the “result” variable to the original input number.

If they are equal, the input number is a Disarium Number; otherwise, it is not. We will use an if-else condition to achieve this.

Here’s an example:

```
if int(num) == result:
print(num, "is a Disarium Number.")
else:
print(num, "is not a Disarium Number.")
```

In the code above, we compare the “result” variable to the original input number using an if-else condition. If they are equal, we print that the number is a Disarium Number.

Otherwise, we print that the input number is not a Disarium Number.

### Output Samples for the Code

Lastly, let’s test the program for two inputs to see if it works correctly.

Example Input 1: 175

Output: 175 is a Disarium Number.

Example Input 2: 518

Output: 518 is a Disarium Number. Here’s the code that generates the output:

```
num = input("Enter a number: ")
result = 0
temp = num[:]
while temp != 0:
digit = temp % 10
result += pow(digit, len(num))
temp //= 10
if int(num) == result:
print(num, "is a Disarium Number.")
else:
print(num, "is not a Disarium Number.")
```

In conclusion, Disarium Numbers can be easily checked for using an algorithm and implemented in Python using the steps mentioned above.

By following these steps, we can determine if a number is a Disarium Number or not with ease.

## Conclusion

In this article, we explored the concept of Disarium Numbers, what they are, and how we can identify them. We learned that Disarium Numbers are those numbers in which the sum of its digits raised to their corresponding position in the number equals the number itself.

We delved into an algorithm that provides a step-by-step process for checking if a number is a Disarium Number. We also provided a PseudoCode example, which outlined how to identify a Disarium Number with inputs from the user.

Further, we covered implementing a Disarium Number check in Python. We started by initializing the variables necessary for the operation such as the input number, result, and a copy of the input number.

We then traversed through the number’s digits and updated the “result” variable accordingly using a while loop. Finally, we checked if the number is a Disarium Number or not using an if-else condition block.

Lastly, we tested the Python program for two input numbers, showing that it works correctly. To summarize, Disarium Numbers are interesting numbers that have unique characteristics and are worth studying.

In this article, we covered what Disarium Numbers are, how to identify them using an algorithm and PseudoCode example, and how to implement a Disarium Number check in Python. With a few lines of code, we were able to apply the algorithm and PseudoCode we learned to determine if a specific number is a Disarium Number or not.

By understanding this concept, we can obtain a deeper insight into the fascinating world of mathematics and its endless possibilities. In conclusion, Disarium Numbers are a unique set of numbers that can be identified using an algorithm where the sum of their digits, raised to the corresponding power as their position, equals the number itself.

We have seen the definition of Disarium Numbers, examples, and gone through an algorithm and a PseudoCode example for identifying them. Additionally, we have implemented a Disarium Number check in Python, enabling us to quickly identify whether a number is a Disarium Number.

The topic of Disarium Numbers is essential in mathematics and highlights the exciting anomalies and patterns that make the subject so captivating. By understanding this concept, we gain insights into the intricacies of numbers and their properties.