Get free ebooK with 50 must do coding Question for Product Based Companies solved
Fill the details & get ebook over email
Thank You!
We have sent the Ebook on 50 Must Do Coding Questions for Product Based Companies Solved over your email. All the best!

Strong Number or Not Using Java

Last Updated on May 31, 2023 by Mayank Dham

A number is said to be a Strong number if the sum of factorials of its digits equals the same input number. To be more specific, we must find the factorial of each digit of the given number. Then we must compute the sum of those factorials. Then we must compare the sum value and the input number; if they are the same, the given number is a strong number; otherwise, it is not. In this article, we’ll look at how to use the Java programming language to determine whether a number is a strong number.

Examples of Strong numbers
Eg 1:
The number entered is 145.
The sum of the factorials of 1, 4, and 5 is 1, 24, and 120.
The total of these factorials equals 1 + 24 + 120 = 145.

As we can see, the sum of the factorials and the input value are both the same. Hence, 145 is a strong number.

Eg 2:
The number entered is 534.
The factorial of 5, 3, and 4 is 120, 6, and 24 respectively.
The total of these factorials equals 120 + 6 + 24 = 150.

As we can see, the sum of the factorials and the input value are not the same thing. As a result, 534 is not a Strong number.

We will discuss various approaches to resolving this issue.

Method 1: Using iteration to find whether a number is a strong number or not in Java

• We’ll define a function that accepts a number and returns its factorial value.
• Using the modulo and divide operators, we divided the number into individual digits.
• We then use the user-defined function to compute their factorial.
• We add up all of the factorial values and compare them to the original number.

Code Implementation

```public class Main
{
static int facto (int n)
{
int fact = 1;

for (int i = 1; i <= n; i++)
fact = fact * i;
return fact;
}
static boolean detectStrong (int num)
{

int digit, sum = 0;
int temp = num;
boolean flag = false;
while (temp != 0)
{
digit = temp % 10;
sum = sum + facto (digit);
temp /= 10;
}
if (sum == num)
flag = true;
else
flag = false;

return flag;
}
public static void main (String[]args)
{

int num = 145;
if (detectStrong (num))
System.out.println (num + " is Strong Number");
else
System.out.println (num + " is not a Strong Number");
}
}
```

Output

``145 is Strong Number ``

Method 2: Using recursion to find whether a number is a strong number or not in Java

• First, we’ll define a recursive function that accepts a number as an argument and returns its factorial value.
• The number is then broken down using the modulo and divide operators to extract the digits and shorten the number, respectively.
• For each number, we then call the factorial function we declared earlier.
• Finally, we add up all of the factorial values and compare them to the original number.

Code Implementation

```public class Main
{
public static void main (String[]args)
{

int num = 145;

if (detectStrong (num))
System.out.println (num + " is Strong Number");
else
System.out.println (num + " is not a Strong Number");
}
static int facto (int num)
{
if(num == 0)
return 1;

return num * facto(num-1);
}

static boolean detectStrong (int num)
{

int digit, sum = 0;
int temp = num;

while(temp!=0){
digit = temp % 10;

sum = sum + facto(digit);
temp /= 10;
}

return sum == num;

}
}
```

Output

``145 is Strong Number  ``

Method 3: Using dynamic programming to find whether a number is a strong number or not in Java

• This method employs dynamic programming to compute factorial values in advance.
• This is advantageous because we may not have to recalculate factorials for new digits repeatedly.

Code Implementation

```public class Main
{
static int f[] = new int[10];
static void preComputer()
{
f[0] = f[1] = 1;
for (int i = 2; i<10; ++i)
f[i] = f[i-1] * i;
}

static boolean checkStrong(int num)
{
int sum = 0;
int temp = num;

while (temp > 0)
{
sum += f[temp % 10];
temp = temp / 10;
}
return (sum == num);
}

public static void main (String[] args)
{
preComputer();
int val = 145;

if(checkStrong(val))
System.out.println(val + " is a strong number");
else
System.out.println(val + " is not a strong number");
}
}
```

Output

``145 is a strong number  ``

Conclusion
Finally, this article discussed various Java methods for determining whether a number is a strong number or not. Strong numbers have the property that the sum of their factorials equals the original number. The article demonstrated three approaches: iteration, recursion, and dynamic programming. Each method provides a method for calculating the factorials and comparing the sum to the input number. Programmers can easily identify strong numbers in Java by implementing these methods.