# Program for Armstrong Numbers

Given a number x, determine whether the given number is Armstrong’s number or not.

A positive integer of n digits is called an Armstrong number of order n (order is the number of digits) if

`abcd... = pow(a,n) + pow(b,n) + pow(c,n) + pow(d,n) + .... `

Example:

Input:153
Output: Yes
153 is an Armstrong number.
1*1*1 + 5*5*5 + 3*3*3 = 153

Input: 120
Output: No
120 is not a Armstrong number.
1*1*1 + 2*2*2 + 0*0*0 = 9

Input: 1253
Output: No
1253 is not a Armstrong Number
1*1*1*1 + 2*2*2*2 + 5*5*5*5 + 3*3*3*3 = 723

Input: 1634
Output: Yes
1*1*1*1 + 6*6*6*6 + 3*3*3*3 + 4*4*4*4 = 1634

Recommended Practice

### Naive Approach

The idea is to first count the number of digits (or find the order).

Algorithm:

1. Let the number of digits be n.
2. For every digit r in input number x, compute rn
3. If the sum of all such values is equal to x, then return true, else false.

Below is the program to check whether the number is an Armstrong number or not:

## C++

 `// C++ program to determine whether ` `// the number is Armstrong number or not` `#include ` `using` `namespace` `std;`   `// Function to calculate x raised ` `// to the power y ` `int` `power(``int` `x, unsigned ``int` `y)` `{` `    ``if` `(y == 0)` `        ``return` `1;` `    ``if` `(y % 2 == 0)` `        ``return` `power(x, y / 2) * power(x, y / 2);` `    ``return` `x * power(x, y / 2) * power(x, y / 2);` `}`   `/* Function to calculate order of the number */` `int` `order(``int` `x)` `{` `    ``int` `n = 0;` `    ``while` `(x) {` `        ``n++;` `        ``x = x / 10;` `    ``}` `    ``return` `n;` `}`   `// Function to check whether the given ` `// number is Armstrong number or not` `bool` `isArmstrong(``int` `x)` `{` `    ``// Calling order function` `    ``int` `n = order(x);` `    ``int` `temp = x, sum = 0;` `    ``while` `(temp) {` `        ``int` `r = temp % 10;` `        ``sum += power(r, n);` `        ``temp = temp / 10;` `    ``}`   `    ``// If satisfies Armstrong condition` `    ``return` `(sum == x);` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `x = 153;` `    ``cout << boolalpha << isArmstrong(x) << endl;` `    ``x = 1253;` `    ``cout << boolalpha << isArmstrong(x) << endl;` `    ``return` `0;` `}`

## C

 `// C program to find Armstrong number` `#include `   `// Function to calculate x raised to ` `// the power y ` `int` `power(``int` `x, unsigned ``int` `y)` `{` `    ``if` `(y == 0)` `        ``return` `1;` `    ``if` `(y % 2 == 0)` `        ``return` `power(x, y / 2) * power(x, y / 2);` `    ``return` `x * power(x, y / 2) * power(x, y / 2);` `}`   `// Function to calculate order of the number ` `int` `order(``int` `x)` `{` `    ``int` `n = 0;` `    ``while` `(x) {` `        ``n++;` `        ``x = x / 10;` `    ``}` `    ``return` `n;` `}`   `// Function to check whether the ` `// given number is Armstrong number or not` `int` `isArmstrong(``int` `x)` `{` `    ``// Calling order function` `    ``int` `n = order(x);` `    ``int` `temp = x, sum = 0;` `    ``while` `(temp) {` `        ``int` `r = temp % 10;` `        ``sum += power(r, n);` `        ``temp = temp / 10;` `    ``}`   `    ``// If satisfies Armstrong condition` `    ``if` `(sum == x)` `        ``return` `1;` `    ``else` `        ``return` `0;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `x = 153;` `    ``if` `(isArmstrong(x) == 1)` `        ``printf``(``"True\n"``);` `    ``else` `        ``printf``(``"False\n"``);`   `    ``x = 1253;` `    ``if` `(isArmstrong(x) == 1)` `        ``printf``(``"True\n"``);` `    ``else` `        ``printf``(``"False\n"``);`   `    ``return` `0;` `}`

## Java

 `// Java program to determine whether ` `// the number is Armstrong number or not` `public` `class` `Armstrong {` `    `  `    ``// Function to calculate x raised ` `    ``// to the power y ` `    ``int` `power(``int` `x, ``long` `y)` `    ``{` `        ``if` `(y == ``0``)` `            ``return` `1``;` `        ``if` `(y % ``2` `== ``0``)` `            ``return` `power(x, y / ``2``) * power(x, y / ``2``);` `        ``return` `x * power(x, y / ``2``) * power(x, y / ``2``);` `    ``}`   `    ``// Function to calculate order of the number ` `    ``int` `order(``int` `x)` `    ``{` `        ``int` `n = ``0``;` `        ``while` `(x != ``0``) {` `            ``n++;` `            ``x = x / ``10``;` `        ``}` `        ``return` `n;` `    ``}`   `    ``// Function to check whether the given ` `    ``// number is Armstrong number or not` `    ``boolean` `isArmstrong(``int` `x)` `    ``{` `        ``// Calling order function` `        ``int` `n = order(x);` `        ``int` `temp = x, sum = ``0``;` `        ``while` `(temp != ``0``) {` `            ``int` `r = temp % ``10``;` `            ``sum = sum + power(r, n);` `            ``temp = temp / ``10``;` `        ``}`   `        ``// If satisfies Armstrong condition` `        ``return` `(sum == x);` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``Armstrong ob = ``new` `Armstrong();` `        ``int` `x = ``153``;` `        ``System.out.println(ob.isArmstrong(x));` `        ``x = ``1253``;` `        ``System.out.println(ob.isArmstrong(x));` `    ``}` `}`

## Python3

 `# python3 >= 3.6 for typehint support` `# This example avoids the complexity of ordering` `# through type conversions & string manipulation`     `def` `isArmstrong(val: ``int``) ``-``> ``bool``:` `    ``"""val will be tested to see if its an Armstrong number. ` `    ``Arguments:` `        ``val {int} -- positive integer only. ` `    ``Returns:` `        ``bool -- true is /false isn't` `    ``"""`   `    ``# break the int into its respective digits` `    ``parts ``=` `[``int``(_) ``for` `_ ``in` `str``(val)]`   `    ``# begin test.` `    ``counter ``=` `0` `    ``for` `_ ``in` `parts:` `        ``counter ``+``=` `_``*``*``3` `    ``return` `(counter ``=``=` `val)`     `# Check Armstrong number` `print``(isArmstrong(``153``))`   `print``(isArmstrong(``1253``))`

## Python

 `# Python program to determine whether the number is` `# Armstrong number or not`   `# Function to calculate x raised to the power y`     `def` `power(x, y):` `    ``if` `y ``=``=` `0``:` `        ``return` `1` `    ``if` `y ``%` `2` `=``=` `0``:` `        ``return` `power(x, y``/``2``)``*``power(x, y``/``2``)` `    ``return` `x``*``power(x, y``/``2``)``*``power(x, y``/``2``)`   `# Function to calculate order of the number`     `def` `order(x):`   `    ``# variable to store of the number` `    ``n ``=` `0` `    ``while` `(x !``=` `0``):` `        ``n ``=` `n``+``1` `        ``x ``=` `x``/``10` `    ``return` `n`   `# Function to check whether the given number is` `# Armstrong number or not`     `def` `isArmstrong(x):` `    ``n ``=` `order(x)` `    ``temp ``=` `x` `    ``sum1 ``=` `0` `    ``while` `(temp !``=` `0``):` `        ``r ``=` `temp ``%` `10` `        ``sum1 ``=` `sum1 ``+` `power(r, n)` `        ``temp ``=` `temp``/``10`   `    ``# If condition satisfies` `    ``return` `(sum1 ``=``=` `x)`     `# Driver Program` `x ``=` `153` `print``(isArmstrong(x))` `x ``=` `1253` `print``(isArmstrong(x))`

## C#

 `// C# program to determine whether the` `// number is Armstrong number or not` `using` `System;`   `public` `class` `GFG {`   `    ``// Function to calculate x raised` `    ``// to the power y` `    ``int` `power(``int` `x, ``long` `y)` `    ``{` `        ``if` `(y == 0)` `            ``return` `1;` `        ``if` `(y % 2 == 0)` `            ``return` `power(x, y / 2) * power(x, y / 2);`   `        ``return` `x * power(x, y / 2) * power(x, y / 2);` `    ``}`   `    ``// Function to calculate` `    ``// order of the number` `    ``int` `order(``int` `x)` `    ``{` `        ``int` `n = 0;` `        ``while` `(x != 0) {` `            ``n++;` `            ``x = x / 10;` `        ``}` `        ``return` `n;` `    ``}`   `    ``// Function to check whether the` `    ``// given number is Armstrong number` `    ``// or not` `    ``bool` `isArmstrong(``int` `x)` `    ``{`   `        ``// Calling order function` `        ``int` `n = order(x);` `        ``int` `temp = x, sum = 0;` `        ``while` `(temp != 0) {` `            ``int` `r = temp % 10;` `            ``sum = sum + power(r, n);` `            ``temp = temp / 10;` `        ``}`   `        ``// If satisfies Armstrong condition` `        ``return` `(sum == x);` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``GFG ob = ``new` `GFG();` `        ``int` `x = 153;` `        ``Console.WriteLine(ob.isArmstrong(x));` `        ``x = 1253;` `        ``Console.WriteLine(ob.isArmstrong(x));` `    ``}` `}`   `// This code is contributed by Nitin Mittal.`

## Javascript

 ``

Output

```true
false
```

### Optimized Approach

Below is the shorter way to implement the above approach:

## C++

 `// C++ program to check whether the` `// number is an Armstrong number or not` `#include ` `using` `namespace` `std;`   `// Driver Code` `int` `main()` `{` `    ``int` `n = 153;` `    ``int` `temp = n;` `    ``int` `p = 0;`   `    ``// Function to calculate the sum of` `    ``// individual digits` `    ``while` `(n > 0) {` `        ``int` `rem = n % 10;` `        ``p = (p) + (rem * rem * rem);` `        ``n = n / 10;` `    ``}`   `    ``// Condition to check whether the value` `    ``// of P equals to user input or not.` `    ``if` `(temp == p) {` `        ``cout << (``"Yes. It is Armstrong No."``);` `    ``}` `    ``else` `{` `        ``cout << (``"No. It is not an Armstrong No."``);` `    ``}` `    ``return` `0;` `}` `// This code is contributed by sathiyamoorthics19`

## C

 `// C program to check whether the given` `// number is an Armstrong number or not` `#include `   `// Driver Code` `int` `main()` `{` `    ``int` `n = 153;` `    ``int` `temp = n;` `    ``int` `p = 0;`   `    ``// Function to calculate the sum of` `    ``// individual digits` `    ``while` `(n > 0) {` `        ``int` `rem = n % 10;` `        ``p = (p) + (rem * rem * rem);` `        ``n = n / 10;` `    ``}`   `    ``// Condition to check whether the value` `    ``// of P equals to user input or not.` `    ``if` `(temp == p) {` `        ``printf``(``"Yes. It is Armstrong No."``);` `    ``}` `    ``else` `{` `        ``printf``(``"No. It is not an Armstrong No."``);` `    ``}` `    ``return` `0;` `}`   `// This code is contributed by sathiyamoorthics19`

## Java

 `// Java program to determine whether the` `// number is Armstrong number or not` `public` `class` `ArmstrongNumber {` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `n = ``153``;` `        ``int` `temp = n;` `        ``int` `p = ``0``;`   `        ``// Function to calculate the sum of` `        ``// individual digits` `        ``while` `(n > ``0``) {` `            ``int` `rem = n % ``10``;` `            ``p = (p) + (rem * rem * rem);` `            ``n = n / ``10``;` `        ``}`   `        ``// Condition to check whether the value` `        ``// of P equals to user input or not.` `        ``if` `(temp == p) {` `            ``System.out.println(``"Yes. It is Armstrong No."``);` `        ``}` `        ``else` `{` `            ``System.out.println(` `                ``"No. It is not an Armstrong No."``);` `        ``}` `    ``}` `}`

## Python3

 `n ``=` `153` `temp ``=` `n` `p ``=` `0`   `# function to calculate` `# the sum of individual digits` `while` `(n > ``0``):` `    ``rem ``=` `n ``%` `10` `    ``p ``=` `(p) ``+` `(rem ``*` `rem ``*` `rem)` `    ``n ``=` `n ``/``/` `10` `if` `temp ``=``=` `p:` `    ``print``(``"armstrong"``)` `else``:` `    ``print``(``"not a armstrong number"``)`   `    ``# This code is contributed by ksrikanth0498.`

## C#

 `// C# program to determine whether the number is` `// Armstrong number or not` `using` `System;`   `public` `class` `ArmstrongNumber {` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{`   `        ``int` `n = 153;` `        ``int` `temp = n;` `        ``int` `p = 0;`   `        ``/*function to calculate` `          ``the sum of individual digits` `         ``*/` `        ``while` `(n > 0) {`   `            ``int` `rem = n % 10;` `            ``p = (p) + (rem * rem * rem);` `            ``n = n / 10;` `        ``}`   `        ``/* condition to check whether` `           ``the value of P equals` `           ``to user input or not. */` `        ``if` `(temp == p) {` `            ``Console.WriteLine(``"Yes. It is Armstrong No."``);` `        ``}` `        ``else` `{` `            ``Console.WriteLine(` `                ``"No. It is not an Armstrong No."``);` `        ``}` `    ``}` `}`   `// This code is contributed by phasing17`

## Javascript

 `// JavaScript implementation of the approach`   `let n = 153;` `let temp = n;` `let p = 0;`   `/*function to calculate` `the sum of individual digits */` `while` `(n > 0) {`   `    ``let rem = n % 10;` `    ``p = (p) + (rem * rem * rem);` `    ``n = Math.floor(n / 10);` `}`   `/* condition to check whether` `   ``the value of P equals` `   ``to user input or not. */` `if` `(temp == p) {` `    ``console.log(``"Yes. It is Armstrong No."``);` `}` `else` `{` `    ``console.log(``"No. It is not an Armstrong No."``);` `}`   `// This code is contributed by phasing17`

Output

```Yes. It is Armstrong No.
```

Time complexity: O(log n)

Auxiliary Space:O(1)

### Find nth Armstrong Number

Input: 9
Output: 9

Input: 10
Output: 153

Below is the program to find the nth Armstrong number:

## C++

 `// C++ Program to find` `// Nth Armstrong Number` `#include ` `#include ` `using` `namespace` `std;`   `// Function to find Nth Armstrong Number` `int` `NthArmstrong(``int` `n)` `{` `    ``int` `count = 0;`   `    ``// upper limit from integer` `    ``for` `(``int` `i = 1; i <= INT_MAX; i++) {` `        ``int` `num = i, rem, digit = 0, sum = 0;`   `        ``// Copy the value for num in num` `        ``num = i;`   `        ``// Find total digits in num` `        ``digit = (``int``)``log10``(num) + 1;`   `        ``// Calculate sum of power of digits` `        ``while` `(num > 0) {` `            ``rem = num % 10;` `            ``sum = sum + ``pow``(rem, digit);` `            ``num = num / 10;` `        ``}` `        ``// Check for Armstrong number` `        ``if` `(i == sum)` `            ``count++;` `        ``if` `(count == n)` `            ``return` `i;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `n = 12;` `    ``cout << NthArmstrong(n);` `    ``return` `0;` `}`   `// This Code is Contributed by 'jaingyayak'`

## C

 `// C Program to find` `// Nth Armstrong Number` `#include ` `#include ` `#include `   `// Function to find Nth Armstrong Number` `int` `NthArmstrong(``int` `n)` `{` `    ``int` `count = 0;`   `    ``// upper limit from integer` `    ``for` `(``int` `i = 1; i <= INT_MAX; i++) {` `        ``int` `num = i, rem, digit = 0, sum = 0;`   `        ``// Copy the value for num in num` `        ``num = i;`   `        ``// Find total digits in num` `        ``digit = (``int``)``log10``(num) + 1;`   `        ``// Calculate sum of power of digits` `        ``while` `(num > 0) {` `            ``rem = num % 10;` `            ``sum = sum + ``pow``(rem, digit);` `            ``num = num / 10;` `        ``}` `        ``// Check for Armstrong number` `        ``if` `(i == sum)` `            ``count++;` `        ``if` `(count == n)` `            ``return` `i;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `n = 12;` `    ``printf``(``"%d"``, NthArmstrong(n));` `    ``return` `0;` `}`   `// This Code is Contributed by 'sathiyamoorthics19'`

## Java

 `// Java Program to find` `// Nth Armstrong Number` `import` `java.lang.Math;`   `class` `GFG {`   `    ``// Function to find Nth Armstrong Number` `    ``static` `int` `NthArmstrong(``int` `n)` `    ``{` `        ``int` `count = ``0``;`   `        ``// upper limit from integer` `        ``for` `(``int` `i = ``1``; i <= Integer.MAX_VALUE; i++) {` `            ``int` `num = i, rem, digit = ``0``, sum = ``0``;`   `            ``// Copy the value for num in num` `            ``num = i;`   `            ``// Find total digits in num` `            ``digit = (``int``)Math.log10(num) + ``1``;`   `            ``// Calculate sum of power of digits` `            ``while` `(num > ``0``) {` `                ``rem = num % ``10``;` `                ``sum = sum + (``int``)Math.pow(rem, digit);` `                ``num = num / ``10``;` `            ``}`   `            ``// Check for Armstrong number` `            ``if` `(i == sum)` `                ``count++;` `            ``if` `(count == n)` `                ``return` `i;` `        ``}` `        ``return` `n;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `n = ``12``;` `        ``System.out.println(NthArmstrong(n));` `    ``}` `}`   `// This code is contributed by Code_Mech.`

## Python3

 `# Python3 Program to find Nth Armstrong Number` `import` `math` `import` `sys`   `# Function to find Nth Armstrong Number`     `def` `NthArmstrong(n):`   `    ``count ``=` `0`   `    ``# upper limit from integer` `    ``for` `i ``in` `range``(``1``, sys.maxsize):`   `        ``num ``=` `i` `        ``rem ``=` `0` `        ``digit ``=` `0` `        ``sum` `=` `0`   `        ``# Copy the value for num in num` `        ``num ``=` `i`   `        ``# Find total digits in num` `        ``digit ``=` `int``(math.log10(num) ``+` `1``)`   `        ``# Calculate sum of power of digits` `        ``while``(num > ``0``):` `            ``rem ``=` `num ``%` `10` `            ``sum` `=` `sum` `+` `pow``(rem, digit)` `            ``num ``=` `num ``/``/` `10`   `        ``# Check for Armstrong number` `        ``if``(i ``=``=` `sum``):` `            ``count ``+``=` `1` `        ``if``(count ``=``=` `n):` `            ``return` `i`     `# Driver Code` `n ``=` `12` `print``(NthArmstrong(n))`   `# This code is contributed by chandan_jnu`

## C#

 `// C# Program to find` `// Nth Armstrong Number` `using` `System;`   `class` `GFG {`   `    ``// Function to find Nth Armstrong Number` `    ``static` `int` `NthArmstrong(``int` `n)` `    ``{` `        ``int` `count = 0;`   `        ``// upper limit from integer` `        ``for` `(``int` `i = 1; i <= ``int``.MaxValue; i++) {` `            ``int` `num = i, rem, digit = 0, sum = 0;`   `            ``// Copy the value for num in num` `            ``num = i;`   `            ``// Find total digits in num` `            ``digit = (``int``)Math.Log10(num) + 1;`   `            ``// Calculate sum of power of digits` `            ``while` `(num > 0) {` `                ``rem = num % 10;` `                ``sum = sum + (``int``)Math.Pow(rem, digit);` `                ``num = num / 10;` `            ``}`   `            ``// Check for Armstrong number` `            ``if` `(i == sum)` `                ``count++;` `            ``if` `(count == n)` `                ``return` `i;` `        ``}` `        ``return` `n;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `n = 12;` `        ``Console.WriteLine(NthArmstrong(n));` `    ``}` `}`   `// This code is contributed by Code_Mech.`

## Javascript

 ``

## PHP

 ` 0)` `        ``{ ` `            ``\$rem` `= ``\$num` `% 10;` `            ``\$sum` `= ``\$sum` `+ pow(``\$rem``, ` `                              ``\$digit``);` `            ``\$num` `= (int)``\$num` `/ 10;` `        ``}` `        `  `        ``// Check for ` `        ``// Armstrong number ` `        ``if``(``\$i` `== ``\$sum``)` `            ``\$count``++;` `        ``if``(``\$count` `== ``\$n``)` `            ``return` `\$i``;` `    ``}` `}`   `// Driver Code` `\$n` `= 12;` `echo` `NthArmstrong(``\$n``);`   `// This Code is Contributed ` `// by akt_mit` `?>`

Output

```371
```

Time complexity: O(log n)

Auxiliary Space: O(1)

### Using Numeric Strings

When considering the number as a string we can access any digit we want and perform operations. Below is the program to implement the above approach:

## C++

 `// C++ program to check whether the` `// number is Armstrong number or not` `#include `   `using` `namespace` `std;`   `string armstrong(``int` `n)` `{` `    ``string number = to_string(n);`   `    ``n = number.length();` `    ``long` `long` `output = 0;` `    ``for` `(``char` `i : number)` `        ``output = output + (``long``)``pow``((i - ``'0'``), n);`   `    ``if` `(output == stoll(number))` `        ``return` `(``"True"``);` `    ``else` `        ``return` `(``"False"``);` `}`   `// Driver Code` `int` `main()` `{` `    ``cout << armstrong(153) << endl;` `    ``cout << armstrong(1253) << endl;` `}`   `// This code is contributed by phasing17`

## Java

 `// Java program to check whether the` `// number is Armstrong number or not` `public` `class` `armstrongNumber {` `    ``public` `void` `isArmstrong(String n)` `    ``{` `        ``char``[] s = n.toCharArray();` `        ``int` `size = s.length;` `        ``int` `sum = ``0``;`   `        ``for` `(``char` `num : s) {` `            ``int` `temp = ``1``;` `            ``int` `i` `                ``= Integer.parseInt(Character.toString(num));`   `            ``for` `(``int` `j = ``0``; j <= size - ``1``; j++) {` `                ``temp *= i;` `            ``}` `            ``sum += temp;` `        ``}`   `        ``if` `(sum == Integer.parseInt(n)) {` `            ``System.out.println(``"True"``);` `        ``}` `        ``else` `{` `            ``System.out.println(``"False"``);` `        ``}` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``armstrongNumber am = ``new` `armstrongNumber();` `        ``am.isArmstrong(``"153"``);` `        ``am.isArmstrong(``"1253"``);` `    ``}` `}`

## Python3

 `def` `armstrong(n):` `    ``number ``=` `str``(n)`   `    ``n ``=` `len``(number)` `    ``output ``=` `0` `    ``for` `i ``in` `number:` `        ``output ``=` `output``+``int``(i)``*``*``n`   `    ``if` `output ``=``=` `int``(number):` `        ``return``(``True``)` `    ``else``:` `        ``return``(``False``)`     `print``(armstrong(``153``))` `print``(armstrong(``1253``))`

## C#

 `using` `System;` `public` `class` `armstrongNumber {` `    ``public` `void` `isArmstrong(String n)` `    ``{` `        ``char``[] s = n.ToCharArray();` `        ``int` `size = s.Length;` `        ``int` `sum = 0;` `        ``foreach``(``char` `num ``in` `s)` `        ``{` `            ``int` `temp = 1;` `            ``int` `i = Int32.Parse(``char``.ToString(num));` `            ``for` `(``int` `j = 0; j <= size - 1; j++) {` `                ``temp *= i;` `            ``}` `            ``sum += temp;` `        ``}` `        ``if` `(sum == Int32.Parse(n)) {` `            ``Console.WriteLine(``"True"``);` `        ``}` `        ``else` `{` `            ``Console.WriteLine(``"False"``);` `        ``}` `    ``}`   `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``armstrongNumber am = ``new` `armstrongNumber();` `        ``am.isArmstrong(``"153"``);` `        ``am.isArmstrong(``"1253"``);` `    ``}` `}`   `// This code is contributed by umadevi9616`

## Javascript

 ``

Output

```True
False
```

Time Complexity: O(n).
Auxiliary Space: O(1).

### Find all Armstrong Numbers in a Range

Below is the program to find all Armstrong numbers in a given range:

## C++

 `// C++ program to find all Armstrong numbers` `// in a given range` `#include ` `using` `namespace` `std;`   `void` `isArmstrong(``int` `left, ``int` `right)` `{` `    ``for` `(``int` `i = left; i <= right; i++) {` `        ``int` `sum = 0;` `        ``int` `temp = i;` `        ``while` `(temp > 0) {` `            ``// Finding the lastdigit` `            ``int` `lastdigit = temp % 10;`   `            ``// Finding the sum` `            ``sum += ``pow``(lastdigit, 3);` `            ``temp /= 10;` `        ``}`   `        ``// Condition to print the number if` `        ``// it is armstrong number` `        ``if` `(sum == i) {` `            ``cout << i << ``" "``;` `        ``}` `    ``}` `    ``cout << endl;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `left = 5, right = 1000;` `    ``isArmstrong(left, right);` `    ``return` `0;` `}`   `// This code is contributed by 525tamannacse11`

## Java

 `// Java program to find all Armstrong numbers` `// in a given range`   `// Importing necessary libraries` `import` `java.util.*;`   `public` `class` `Main {` `    ``public` `static` `void` `isArmstrong(``int` `left, ``int` `right)` `    ``{` `        ``for` `(``int` `i = left; i <= right; i++) {` `            ``int` `sum = ``0``;` `            ``int` `temp = i;` `            ``while` `(temp > ``0``) {` `                ``// Finding the last digit` `                ``int` `lastdigit = temp % ``10``;`   `                ``// Finding the sum` `                ``sum += Math.pow(lastdigit, ``3``);` `                ``temp /= ``10``;` `            ``}`   `            ``// Condition to print the number if it` `            ``// is an Armstrong number` `            ``if` `(sum == i) {` `                ``System.out.print(i + ``" "``);` `            ``}` `        ``}` `        ``System.out.println();` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `left = ``5``, right = ``1000``;` `        ``isArmstrong(left, right);` `    ``}` `}`

## Python3

 `def` `armstrong(n):` `    ``number ``=` `str``(n)`   `    ``n ``=` `len``(number)` `    ``output ``=` `0` `    ``for` `i ``in` `number:` `        ``output ``=` `output``+``int``(i)``*``*``n`   `    ``if` `output ``=``=` `int``(number):` `        ``return``(``True``)` `    ``else``:` `        ``return``(``False``)`     `arm_list ``=` `[]`   `nums ``=` `range``(``10``, ``1000``)`   `for` `i ``in` `nums:` `    ``if` `armstrong(i):` `        ``arm_list.append(i)` `    ``else``:` `        ``pass`   `print``(arm_list)`

## C#

 `using` `System;`   `class` `MainClass {` `    ``static` `void` `isArmstrong(``int` `left, ``int` `right)` `    ``{` `        ``for` `(``int` `i = left; i <= right; i++) {` `            ``int` `sum = 0;` `            ``int` `temp = i;` `            ``while` `(temp > 0) {` `                ``// finding the lastdigit` `                ``int` `lastdigit = temp % 10;` `                ``// finding the sum` `                ``sum += (``int``)Math.Pow(lastdigit, 3);` `                ``temp /= 10;` `            ``}` `            ``/* Condition to print the number if it is` `             ``* armstrong number */` `            ``if` `(sum == i) {` `                ``Console.Write(i + ``" "``);` `            ``}` `        ``}` `        ``Console.WriteLine();` `    ``}`   `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``int` `left = 5, right = 1000;` `        ``isArmstrong(left, right);` `    ``}` `}`

## Javascript

 `// JavaScript code to implement the approach` `function` `isArmstrong(left, right) {` `    ``for` `(let i = left; i <= right; i++) {` `        ``let sum = 0;` `        ``let temp = i;` `        ``while` `(temp > 0) {` `            ``// finding the lastdigit` `            ``let lastdigit = temp % 10;` `            ``// finding the sum` `            ``sum += Math.pow(lastdigit, 3);` `            ``temp = Math.floor(temp / 10);` `        ``}` `        ``/* Condition to print the number if it is armstrong number */` `        ``if` `(sum === i) {` `            ``process.stdout.write(i + ``" "``);` `        ``}` `    ``}` `    ``console.log(``"\n"``);` `}`   `// Driver code`   `let left = 5,` `    ``right = 1000;` `isArmstrong(left, right);`   `// This code is contributed by phasing17`

Output

```153 370 371 407
```

This article is contributed by Rahul Agrawal .If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or if you want to share more information about the topic discussed above.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next