Introduction

In this lesson, we will delve into the concept of Armstrong numbers—a fascinating mathematical property. Armstrong numbers, also known as narcissistic numbers, are numbers that are equal to the sum of their own digits each raised to the power of the number of digits. Our aim is to understand the mathematical properties of these numbers, utilize loops for iteration over ranges, and implement logic to validate if a given number is an Armstrong number. By the end of this lesson, you'll be equipped to test multiple inputs and determine their Armstrong status using Python.

Understanding Armstrong Numbers

What is an Armstrong Number?

An Armstrong number (narcissistic number for a given base) is characterized by the property that for a given number N with d digits, the sum of its individual digits each raised to the power d equals the number itself. In simple terms:

For a number abcd, it is an Armstrong number if:

[ (a^d) + (b^d) + (c^d) + (d^d) = abcd ]

Example:

Consider the number 153:

• It has 3 digits.
• Calculating: ((1^3) + (5^3) + (3^3) = 1 + 125 + 27 = 153)

This verifies that 153 is indeed an Armstrong number.

Implementing Armstrong Number Check

Step 1: Extract Digits

To check if a number is an Armstrong number, we first need to be able to extract and work with its individual digits. We achieve this through a combination of modulus and division operations and utilize loops for iteration.

Step 2: Sum of Powered Digits

For each digit extracted, we need to raise it to the power equal to the total number of digits and sum these values.

Step 3: Compare Sum to Original Number

Finally, compare this sum to the original number. If they match, the number is an Armstrong number.

Code Example

Let's implement this algorithm in Python:

# Function to check if a number is an Armstrong number

def is_armstrong_number(number):
    # Convert number to string to iterate over digits and count
    num_str = str(number)
    num_digits = len(num_str)
    sum_of_powers = 0
    
    # Calculate the sum of powers of each digit
    for digit in num_str:
        sum_of_powers += int(digit) ** num_digits
    
    # Check if the sum of powered digits equals the original number
    return sum_of_powers == number

# Testing the function
numbers_to_test = [153, 9474, 371, 123]

for num in numbers_to_test:
    result = "is" if is_armstrong_number(num) else "is not"
    print(f"{num} {result} an Armstrong number.")

Expected Output

Running the above script will generate the following output:

153 is an Armstrong number.
9474 is an Armstrong number.
371 is an Armstrong number.
123 is not an Armstrong number.

Testing Multiple Inputs

To enhance usability, we can incorporate user input to allow testing of any number for Armstrong properties.

Consider modifying the test code to receive input from users:

# Accept user input
user_input = input("Enter a number to check for Armstrong property: ")
try:
    user_number = int(user_input)
    if is_armstrong_number(user_number):
        print(f"{user_number} is an Armstrong number.")
    else:
        print(f"{user_number} is not an Armstrong number.")
except ValueError:
    print("Please enter a valid integer.")

This addition enables dynamic simulation of Armstrong number checking, making the code more interactive and user-friendly.

Summary / Key Takeaways

In this lesson, Lesson 22: Armstrong Number Check, you have learned:

• An Armstrong number's definition and mathematical properties
• How to extract and work with the individual digits of a number
• Implementing loops for the calculation of powered sums
• Coding a function to validate whether a number is an Armstrong number
• The practical application of the Armstrong validation algorithm using Python
• Techniques to involve user input for flexible testing