# Strong Number in Java

(Last Updated On: 29/05/2023)

## What is a Strong Number in Java?

Strong numbers, also called factorial numbers, are special numbers that have the property of the sum of the factorial of their digits being equal to the original number.

### Strong numbers in Java Examples:

Let’s examine a few examples to further clarify the idea of strong numbers. Some Strong numbers are as follows:

1. 145: As previously stated, the sum of its digit factorials (1! + 4! + 5!) equals the number itself.
2. 40585: The sum of its factorials (4! + 0! + 5! + 8! + 5!) equals the number itself.
3. 2: 2 is regarded as a strong number even though it is a single digit because 2! = 2.

## Check whether it is a Strong Number or Not

```import java.util.*;
public class Main {
//main method
public static void main(String[] args) {

//declare an int variable and initialize a number as value
int inputNum = 40585;

//declare a variable for iteration
int i;

//declare variables for factorial value and the extracted digits
int factorial,digit;

//declare a variable to store the sum value
int sum = 0;

//transfer the input value to a temporary variable
int temp = inputNum;

//start looping for calculating the result
while(temp != 0) {
i = 1;
factorial = 1;

//extracting the digit
digit = temp % 10;

//get the factorial of the digit
while(i <= digit) {
factorial = factorial * i;
i++;
}

//store the sum value
sum = sum + factorial;

//removing the digit one by one
temp = temp / 10;
}

//check condition
if(sum == inputNum)
//if sum value is equal to input number
System.out.println(inputNum + " is a strong number\n");
else
//if sum value is not equal to input number
System.out.println(inputNum + " is not a strong number\n");
}
}```

Explanation of the code:

An amount that equals the factorial sum of its digits is referred to as a strong number. The inputNum variable is first declared and initialized with a value of 40585 in the program’s opening statement. When determining whether a number is powerful, this one will be used.

By taking the modulus of 10 for each digit of the inputNum inside the while loop, the computer can extract each digit. Following that, a further nested while loop calculates the digit’s factorial. A variable called “factorial” holds the factorial. By adding the factorial value, the sum variable is updated.

The software checks the sum variable with the initial inputNum once the while loop has finished. In the event that they are equal, a message is printed indicating that the inputNum is a strong integer. Otherwise, the software prints a warning indicating that the inputNum is not a strong number if the sum and inputNum are not equal. In the example code, the inputNum is set to 40585, which is a reliable value. As a result, the software will output to the console that “40585 is a strong number.”

#### Output:

`40585 is a strong number`

Also, learn about Emirp Number in Java here!

## Find all the strong numbers in a given range

```import java.util.*;
import java.io.*;
import java.util.Scanner;

class RangeStrong_Number
{
public static void main(String[] args)
{
int n1,n2;

// create scanner class object
Scanner sc =  new Scanner(System.in);

System.out.print("Enter lower range : ");
n1 = sc.nextInt();
System.out.print("Enter upper range : ");
n2 = sc.nextInt();
for (int i = n1; i <= n2; i++)
{
if (isItStrong(i))
{
System.out.println(i);
}
}
}
static boolean isItStrong(int num) {
int no = num;
int sum = 0;
while (no > 0) {
int digit = no % 10;
sum += fact(digit);

no = no / 10;
}
return sum == num;
}
static int fact(int digit) {
int f = 1;
for (int j = digit; j > 1; j--) {
f *= j;
}
return f;
}
}```

Explanation of the code:

Strong numbers are those that are equal to the factorial sum of their digits. The user is first asked to enter the lower and upper range of numbers by the application. The variables n1 and n2 respectively, hold these values.

Each integer in the specified range is iterated using a for loop inside the main procedure. The isItStrong method is called for each number to determine whether it is a strong number. The number is printed to the console if it is.

When given an integer as input, the isItStrong method determines whether the number is a strong one. The factorial of each number digit is calculated using the fact technique utilizing a while loop to extract each digit from the integer. A comparison between the original number and the factorial total is performed. They must be equal in order for the procedure to return true, which indicates that the number is a strong number.

Using a for loop, the fact technique determines the factorial of a given digit. In general, the application lets the user enter a range of numbers, checks those numbers for strong ones, and prints those to the console.

#### Output:

```Enter lower range : 1
Enter upper range : 1000000
12
145
40585```

## Difference between Strong numbers and other types of numbers

Strong numbers are unique in their characteristics and differ from other types of numbers in several ways. Here are the key differences:

Check out our blog on Armstrong Number in Java, here!

### A. Discussing possible optimizations to the Strong Number program

The Strong number program can be optimized for better performance and efficiency.

Memoization: Utilize memoization to store the factorial values of already calculated numbers. By caching the factorial values, the program can avoid recalculating them when checking for strong numbers.

Upper limit optimization: Optimize the program to only check numbers up to the highest input value, reducing computation time and improving the execution speed.

### B. Exploring additional features and functionalities

Consider including the following features and functionalities to further improve the Strong Number program:

User-defined input: Users should be able to enter a range and find all Strong numbers inside that range. The program would become more adaptable and user-friendly as a result.

Counting Strong Numbers: To count all Strong numbers within a specified range, modify the program. The frequency of Strong numbers within a given range would be made known to users thanks to this feature, which would offer them useful information.

Strong number sequence: Make a function that produces a series of Strong numbers up to a predetermined limit. To do this, iterate through the sequence of numbers, determine whether they are Strong numbers, and then add them.

### C. Introducing related topics like Special numbers or Armstrong numbers

In addition to Strong numbers, there are other interesting number concepts worth exploring. Consider introducing the following topics to expand the reader’s understanding:

Special numbers: Perfect, amicable, and triangular numbers are just a few examples of the various special number types. Describe the characteristics that make them special and how to recognize and calculate them.

Armstrong numbers: Explain Armstrong numbers, also called Narcissistic numbers or the sum of their own digits raised to the power of the number of digits. Describe Armstrong numbers’ properties and uses in number theory and cryptography.

Throughout this blog, we have learned how to implement Strong numbers in Java. We have discussed the basic concepts of factorials, provided a step-by-step guide to identifying Strong numbers, and provided a Java program for reference. Following the outlined process and understanding the implementation steps, readers can now create their own Java program to identify Strong numbers accurately and efficiently.

In conclusion, Strong Numbers challenges mathematics and programming, providing valuable knowledge and skills in Java. I encourage everyone to apply this knowledge to practical programming tasks, further explore related topics, and continue their learning journey in the vast world of programming. Keep checking on our  Newtum’s website to explore our online coding courses covering Java, Python, PHP, and more.