• # C Program to Check Armstrong Number Using Function

nally, Welcome to this comprehensive blog post where we will dive deep into the world of Armstrong numbers and learn how to write a C program to check if a number is an Armstrong number or not, using functions. Whether you are new to programming or already familiar with C, this post is for you! So let’s get started.

## Introduction

An Armstrong number is a number that is equal to the sum of its own digits raised to the power of the number of digits. For example, 153 is an Armstrong number because 1³ + 5³ + 3³ = 153. Armstrong numbers are also known as Narcissistic numbers or pluperfect digital invariants.

The purpose of this blog post is to teach you how to write a C program that can determine if a given number is an Armstrong number or not. We will accomplish this by breaking down the problem into smaller steps and implementing these steps in a C program using functions.

## What is a Function in C?

Before we dive into writing the program, let’s quickly understand what a function is in the context of C programming. In simple terms, a function is a block of code that performs a specific task. It takes input, processes it, and produces some output. Functions help us modularize our code and make it more reusable and maintainable.

In our case, we will be writing a function that checks if a number is an Armstrong number or not. This function will take an integer as input and return a boolean value indicating whether the number is an Armstrong number or not.

## Steps to Check Armstrong Number

To determine if a number is an Armstrong number or not, we can follow these steps:

1. Obtain the number from the user.

2. Count the number of digits in the given number.

3. Calculate the sum of each digit raised to the power of the number of digits.

4. Compare the calculated sum with the original number.

5. If the sums match, the number is an Armstrong number. Otherwise, it is not.

Let’s now break down these steps and implement them in our C program.

### Step 1: Obtaining the Number from the User

To get a number from the user, we can make use of the standard input/output functions provided by C. We will use the `scanf()` function to read the number entered by the user and store it in a variable.

Here’s an example code snippet to obtain the number from the user:

``````#include <stdio.h>

int main() {
int number;
printf("Enter a number: ");
scanf("%d", &number);
// Rest of the code goes here
return 0;
}``````

### Step 2: Counting the Number of Digits

To count the number of digits in a given number, we can create a separate function that takes the number as input and returns the count of digits. We can achieve this by using a loop where we divide the number by 10 until the quotient becomes 0, incrementing a counter variable in each iteration.

Let’s write the code for the function `countDigits()`:

``````int countDigits(int number) {
int count = 0;
while (number != 0) {
number = number / 10;
count++;
}
return count;
}``````

### Step 3: Calculating the Sum of Digit Powers

Now that we have the count of digits in the given number, we can calculate the sum of each digit raised to the power of the number of digits. To do this, we will again use a loop, extract each digit from the number, raise it to the power of the count, and accumulate the result in a sum variable.

Here’s the code for the function `calculateSum()`:

``````int calculateSum(int number, int count) {
int sum = 0;
int temp = number; // A temporary variable to store the number

while (temp != 0) {
int digit = temp % 10;
sum += pow(digit, count);
temp /= 10;
}
return sum;
}``````

### Step 4: Comparing the Sums

Now that we have the original number and the calculated sum, we can compare them to determine if the number is an Armstrong number or not. If the two sums match, the number is an Armstrong number. Otherwise, it is not.

``````if (number == sum) {
printf("%d is an Armstrong number.\n", number);
} else {
printf("%d is not an Armstrong number.\n", number);
}``````

### Putting It All Together

Now that we have implemented the necessary functions, let’s put them together in our main program to check if a number is an Armstrong number or not.

``````#include <stdio.h>
#include <math.h>

int countDigits(int number) {
int count = 0;
while (number != 0) {
number = number / 10;
count++;
}
return count;
}

int calculateSum(int number, int count) {
int sum = 0;
int temp = number; // A temporary variable to store the number

while (temp != 0) {
int digit = temp % 10;
sum += pow(digit, count);
temp /= 10;
}
return sum;
}

int main() {
int number;
printf("Enter a number: ");
scanf("%d", &number);

int numOfDigits = countDigits(number);
int sum = calculateSum(number, numOfDigits);

if (number == sum) {
printf("%d is an Armstrong number.\n", number);
} else {
printf("%d is not an Armstrong number.\n", number);
}

return 0;
}``````

### Test Run

Let’s test our program with a few example inputs:

``````Enter a number: 153
153 is an Armstrong number.

Enter a number: 370
370 is an Armstrong number.

Enter a number: 123
123 is not an Armstrong number.``````

As you can see, our program successfully determines whether a given number is an Armstrong number or not.

## Conclusion

Congratulations on making it to the end of this blog post! We have explored the concept of Armstrong numbers and learned how to write a C program to check if a number is an Armstrong number or not, using functions. We broke down the problem into smaller steps and implemented these steps in our C program.

Finally, we covered topics such as obtaining user input, counting the number of digits, calculating the sum of digit powers, and comparing the sums. By combining these concepts and applying them in an organized manner, we were able to create a fully functional program.

I hope you found this blog post informative and helpful in understanding the concept of Armstrong numbers and how to implement a related program in C. Now it’s your turn to explore further and experiment with different numbers. Have fun coding!

To dive further into the subject, consider exploring additional number-related concepts like perfect numbers, strong numbers, and happy numbers. You can also optimize your program for more efficient handling of larger numbers. Furthermore, exploring other programming languages supporting functions and number manipulation could be rewarding.

Happy coding!