factorial method doesn't work well!

Question

Hi this is a factorial method but it prints 0 in the console please help me thanks

public class Demo {

    public static void main(String[] args) {
        Demo obj = new Demo();
        System.out.println(obj.factorial(500));
    }

    public int factorial(int n) {
        int fact = 1;

        for (int i = 2; i <= n; i++) {
            fact= fact*i;
        }
        return fact;
    }

EDITED:will return Infinity!

public class Demo {

    public static void main(String[] args) {
        Demo obj = new Demo();
        System.out.println(obj.factorial(500));
    }

    public double  factorial(long n) {
       double fact = 1;

        for (int i = 2; i <= n; i++) {
            fact= fact*i;
        }
        return fact;
    }
}

Answer 1

There's no way you can fit 500! on a 32-bit int.

For calculations involving large numbers, consider using a double or a BigInteger, depending on whether you want an approximate or an exact answer.

(Actually, for 500!, even a double would not be enough: Double.MAX_VALUE is 1.7976931348623157E+308, which will "only" let you go up to 170!)

Answer 2

Grodriguez is right - this is almost certainly caused by integer overflow.

If you test your method with more modest inputs it appears to return the right output:

public static void main(String[] args) {
   Demo obj = new Demo();
   for (int i = 0; i < 10; i++)
      System.out.println(i + "! = " + obj.factorial(i));
} 

500! is massive; when testing your function, starting with smaller inputs would be prudent.

Answer 3

Since 500! equals 1220136825991110068701238785423046926253574342803192842192413588385845373153881997605496447502203281863013616477148203584163378722078177200480785205159329285477907571939330603772960859086270429174547882424912726344305670173270769461062802310452644218878789465754777149863494367781037644274033827365397471386477878495438489595537537990423241061271326984327745715546309977202781014561081188373709531016356324432987029563896628911658974769572087926928871281780070265174507768410719624390394322536422605234945850129918571501248706961568141625359056693423813008856249246891564126775654481886506593847951775360894005745238940335798476363944905313062323749066445048824665075946735862074637925184200459369692981022263971952597190945217823331756934581508552332820762820023402626907898342451712006207714640979456116127629145951237229913340169552363850942885592018727433795173014586357570828355780158735432768888680120399882384702151467605445407663535984174430480128938313896881639487469658817504506926365338175055478128640000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 you can't fit it into an int (which ranges only up to 2147483647).

• Using an int you can only store up to 12!.
• Using a long you'll get up to 20!
• Using a double you'll get up to 170!.

Here is a solution using BigInteger:

public static BigInteger factorial(int i) {
    BigInteger n = BigInteger.valueOf(i);
    while (--i > 0)
        n = n.multiply(BigInteger.valueOf(i));
    return n;
}

Answer 4

500! is way too big to fit a long, or double.
You would have to use other techniques to get this.

But first, what kind of program needs 500!?

Answer 5

There are two things you should be looking into if you need to calculate the factorial function:

1) Memoization. This will dramatically speed up your calculations, since the factorial function has a recursive definition. What you do is cache previous calculations, so when you ask for k!, you can get it in one step by calculating k*((k-1)!) if you have (k-1)! cached.

2) Stirling's approximation. If you need to calculate large factorials, you can approximate them very rapidly this way, and with guaranteed bounds on the error, so you can tell whether the approximation will be acceptably close for your application.

If you do neither of these, you will find that there is some relatively small k for which you simply can't calculate k! in a reasonable amount of time.

Answer 6

There are some very nice optimization for the implementation of factorizations: see for instance luschny.de for a nice implementation of them in Java. Some require more mathematical insight then others... Have fun with the library :-)