Python Tutorial
.
An Armstrong number in Python is one where the sum of all its digits, each raised to the power of the number of digits, equals the number itself.
To put it another way, if a number has "n" digits and you raise each one to the power of "n," add their values and the result is equal to the original number, the number is an Armstrong number.
Understanding Armstrong numbers can be a great way to deepen your programming skills and enhance your understanding of number theory and mathematical properties. In this tutorial, we will aim to understand the different topics related to Armstrong numbers in Python.
The fascinating mathematical idea of Armstrong numbers is applied in a variety of exercises and programming problems. They offer an engaging way to investigate mathematical properties and coding strategies in many programming languages. In this tutorial, we will delve into the topic of Armstrong numbers in Python and learn what are the different ways we can implement them in Python.
Armstrong numbers in Python are numbers that are the sums of the very digits they are composed of, each raised to the power of the number of digits. It is also referred to as a narcissistic number, a pluperfect digital invariant, or a pluperfect digital number. Fundamentally, the sum of the digits of any n-digit number with all the numbers raised to the powers of n must be equal to the n-digit number to be Armstrong numbers.
For example, 8208 is a 4-digit Armstrong number. The prevalence of Armstrong numbers decreases as the number of digits rises. The largest known Armstrong number in base 10 has 39 digits and is 115,132,219,018,763,992,565,095,597,973,971,522,401.
Let us understand this concept with the help of an example.
Code:
num = 153
#num is the number we want to find if it is an armstrong number or not
digits_num = len(str(num))
temp = num
add_sum = 0
while temp != 0:
# get the last digit in the number
k = temp % 10
add_sum += k**digits_num
# floor division
# updates second last digit as last digit.
temp = temp//10
if add_sum == num:
print('Given number is an Armstrong Number')
else:
print('Given number is not a Armstrong Number')In this approach, we will check if a number is an Armstrong number or not without using the power function. Let us have a look at an example of how to find if a number is an Armstrong number or not without using the power function.
Code:
def count_digits(number):
count = 0
while number > 0:
number //= 10
count += 1
return count
def is_armstrong(number):
original_num = number
num_of_digits = count_digits(number)
sum_of_digits = 0
while number > 0:
digit = number % 10
product = 1
for _ in range(num_of_digits):
product *= digit
sum_of_digits += product
number //= 10
return sum_of_digits == original_num
# Input from the user
number = int(input("Enter a number: "))
if is_armstrong(number):
print(number, "is an Armstrong number.")
else:
print(number, "is not an Armstrong number.")In this program, the count_digits function counts the digits in the inputted number, and the is_armstrong function determines whether the number is an Armstrong number by manually computing each digit's power using a loop, and then adding the powered digits together.
In this section, we will take a look at how to check if a number is an Armstrong number or not using string manipulation with the help of this Python program example.
Code:
def is_armstrong(number):
num_str = str(number)
num_of_digits = len(num_str)
sum_of_digits = 0
for digit_char in num_str:
digit = int(digit_char)
sum_of_digits += digit ** num_of_digits
return sum_of_digits == number
# Input from the user
number = int(input("Enter a number: "))
if is_armstrong(number):
print(number, "is an Armstrong number.")
else:
print(number, "is not an Armstrong number.")The is_armstrong method in this program changes the integer to a string so that you can loop through each of its digits. The sum of the digits raised to the power of the number of digits is then calculated using a loop. An Armstrong number is one where the total is equal to the original number.
Let us understand how to check for an Armstrong number using the digit-by-digit approach with the help of this example below.
Code:
def count_digits(number):
count = 0
while number > 0:
number //= 10
count += 1
return count
def is_armstrong(number):
original_num = number
num_of_digits = count_digits(number)
sum_of_digits = 0
while number > 0:
digit = number % 10
sum_of_digits += digit ** num_of_digits
number //= 10
return sum_of_digits == original_num
# Input from the user
number = int(input("Enter a number: "))
if is_armstrong(number):
print(number, "is an Armstrong number.")
else:
print(number, "is not an Armstrong number.")The is_armstrong function iterates through the digits of the number while the count_digits function counts the number of digits in the inputted number. To determine whether a number is an Armstrong number, it computes the sum of the digits raised to the power of the number of digits and compares it to the original number. The output is boolean in nature, as in true or false.
Let us understand how to check if a number is an Armstrong number in the return statement with the help of an example shown below.
Code:
def is_armstrong(number):
original_num = number
num_str = str(number)
num_of_digits = len(num_str)
sum_of_digits = sum(int(digit_char) ** num_of_digits for digit_char in num_str)
return sum_of_digits == original_num
# Taking input from the user
number = int(input("EPlease enter a number: "))
result = is_armstrong(number)
if result:
print(number, "is an Armstrong number.")
else:
print(number, "is not an Armstrong number.")The is_armstrong function in this program uses a generator expression from the sum function to compute the sum of the digits raised to the power of the number of digits. The comparison's outcome is immediately returned as a boolean. Depending on whether the input number is an Armstrong number or not, the main portion of the code takes the result and outputs the relevant message.
Let us understand this concept with the help of this example of a Python program to find the Armstrong number in an interval.
Code:
def count_digits(number):
count = 0
while number > 0:
number //= 10
count += 1
return count
def is_armstrong(number):
original_num = number
num_of_digits = count_digits(number)
sum_of_digits = 0
while number > 0:
digit = number % 10
sum_of_digits += digit ** num_of_digits
number //= 10
return sum_of_digits == original_num
# Input from the user
lower_limit = int(input("Enter the lower limit of the interval: "))
upper_limit = int(input("Enter the upper limit of the interval: "))
armstrong_numbers = []
for number in range(lower_limit, upper_limit + 1):
if is_armstrong(number):
armstrong_numbers.append(number)
print("Armstrong numbers in the interval:", armstrong_numbers)This program iterates through each number in the interval after receiving the interval's bottom and upper bounds as input. Using the is_armstrong function previously defined, it determines whether each number is an Armstrong number and, if so, adds it to the list of Armstrong numbers. The list of Armstrong numbers that were discovered during the specified timeframe is then printed by the program.
Armstrong numbers, also known as narcissistic numbers or pluperfect numbers, are a topic we covered in this tutorial. We also went through how to tell if a given number is an Armstrong number, using various different methods and techniques. If you wish to learn more about Armstrong numbers and other Python concepts, checking out courses from upGrad might be of great help.
1. Can an Armstrong number in Python have only one digit?
Yes, single-digit numbers are regarded as Armstrong numbers since they meet the criteria for such a number. Armstrong numerals, for instance, range from 0 to 9. 0 to 9 can also be called an Armstrong number list.
2. Are there any Armstrong numbers in the negative range?
For positive integers, Armstrong numbers are frequently taken into account. Because negative numbers' distinctive characteristics are based on digit manipulation, the Armstrong number notion cannot be directly applied to them.
3. Do the Armstrong numbers in Python have any practical uses?
Armstrong numbers are employed in programming and mathematical exercises to teach ideas like loops, conditional statements, and number theory even if they have no immediate practical applicability in real-world situations.
4. Do any effective algorithms exist to locate huge Armstrong numbers?
The prevalence of Armstrong numbers decreases as the number of digits rises. There isn't a single effective algorithm for finding huge Armstrong numbers; instead, it's usual practice to look at each number's properties.
5. Can data science or cryptography employ Armstrong numbers?
Due to their unique mathematical quality, Armstrong numbers are not frequently employed in cryptography or data science, but they can act as a jumping-off point for more complicated number-related concepts.
Leave a Reply
Your email address will not be published. Required fields are marked *