# C Program to Generate Armstrong Numbers

« Previous Program Next Program »

In this article, you will learn and get code to print Armstrong numbers in given range with and without using user-defined function. But before going through program, let's first understand about it.

### What is Armstrong Number ?

An Armstrong number is a number that equals to the sum of its own digits, where each digit raised to the power of number of digits. For example, 153 is an Armstrong number, because:

```153 = 13+53+33
= 1+125+27
= 153```

Since 153 is a 3-digit number, therefore each digit raised to the power of 3. Now let's move on and implement it in a C program.

## Generate Armstrong Numbers in Given Range

This program prints all the Armstrong numbers lies between the range provided by user at run-time.

```#include<stdio.h>
#include<conio.h>
int main()
{
int start, end, temp, noOfDigit, num, res=0, rem, pow, i;
printf("Enter the Interval: ");
scanf("%d%d", &start, &end);
printf("\nArmstrong Numbers between %d and %d:-\n", start, end);
while(start<=end)
{
temp = start;
noOfDigit=0;
while(temp>0)
{
temp = temp/10;
noOfDigit++;
}
num = start;
while(num>0)
{
rem = num%10;
pow = 1;
i = 0;
while(i<noOfDigit)
{
pow = pow*rem;
i++;
}
res = res + pow;
num = num/10;
}
if(res==start)
printf(" %d\n", res);
start++;
res = 0;
}
getch();
return 0;
}```

This program was build and run under Code::Blocks IDE. Here is its sample run:

Now supply and two number as interval say 1 and 5000 to print all the Armstrong numbers between these two. That is, the snapshot given below shows all the Armstrong numbers from 1 to 5000:

Note - Every single digit number is an Armstrong number. Since it is a 1-digit, therefore power raised to it will be 1 (as defined in definition given above), and any number raised to the power of 1 is equal to the number itself.

Therefore, 1, 2, 3, 4, 5, 6, 7, 8, 9, 153, 370, 371, 407, 1634 are Armstrong numbers between 1 to 5000. Because,

• 1 = 11 (digit to the power of 1, for 1-digit number)
• 2 = 21
• 3 = 31
• 4 = 41
• 5 = 51
• 6 = 61
• 7 = 71
• 8 = 81
• 9 = 91
• 153 = 13+53+33 (digit to the power of 3, for 3-digit number)
• 370 = 33+73+03
• 371 = 33+73+13
• 407 = 43+03+73
• 1634 = 14+64+34+44 (digit to the power of 4, for 4-digit number)

The following block of code

```temp = start;
noOfDigit=0;
while(temp>0)
{
temp = temp/10;
noOfDigit++;
}```

is used to find the number of digit for current number. That is, the value of start variable gets initialized to temp and using this variable, this block of code finds that how many digit this number has.

Here is another block of code,

```pow = 1;
i = 0;
while(i<noOfDigit)
{
pow = pow*rem;
i++;
}```

which is used to find digit raised to the power's value. For example, if the current digit is 3 and the number is a 3-digit number, then this block of code will find the value of 33. Now let's create the same purpose program using a user-defined function.

### Using User-defined Function

This program is little simple to understand as it is created using user-defined function. That is, the two block of codes were required to run more than one time, is shifted in the function, and the name of that two functions are findNoOfDigit(int) (finds number of digit) and pow(int rem, int noOfDigit) (finds digit raised to power's value). Finding number of digits means, if a number is 370, therefore it will return 3. Because it is a 3-digit number. Whereas finding digit raised to power's value means, if a digit is 3 (from a 3-digit number), then 33 equals to 27, therefore 27 gets returned by function.

```#include<stdio.h>
#include<conio.h>
int findNoOfDigit(int);
int pow(int, int);
void generateArmNos(int, int);
int main()
{
int start, end;
printf("Enter the Interval: ");
scanf("%d%d", &start, &end);
printf("\nArmstrong Numbers between %d and %d:-\n", start, end);
generateArmNos(start, end);
getch();
return 0;
}
void generateArmNos(int start, int end)
{
int noOfDigit, num, digToPowVal, i, rem, res=0;
while(start<=end)
{
noOfDigit = findNoOfDigit(start);
num = start;
while(num>0)
{
rem = num%10;
digToPowVal = pow(rem, noOfDigit);
res = res+digToPowVal;
num = num/10;
}
if(res==start)
printf(" %d\n", res);
start++;
res = 0;
}
}
int findNoOfDigit(int temp)
{
int noOfDigit=0;
while(temp>0)
{
temp = temp/10;
noOfDigit++;
}
return noOfDigit;
}
int pow(int rem, int noOfDigit)
{
int digToPowVal = 1, i=0;
while(i<noOfDigit)
{
digToPowVal = digToPowVal*rem;
i++;
}
return digToPowVal;
}```

This program produced the same output as of previous one.

#### Same Program in Other Languages

C Online Test

« Previous Program Next Program »