查找在Java中大量的阶乘(Find factorial of large numbers in J

我尝试使用for循环和双数据类型来找到大量如8785856的阶乘的典型方式。

但它显示无穷大的结果，可能是因为它超出了极限。

所以，请指引我找到一个非常大的数的阶乘的方式。

我的代码：

class abc
{
    public static void main (String[]args)
    {
        double fact=1;
        for(int i=1;i<=8785856;i++)
        {
            fact=fact*i;
        }

        System.out.println(fact);
    }
}

输出： -

Infinity

我是新来的Java，但学到的IO处理和所有的一些概念。

Answer 1:

public static void main(String[] args) {
    BigInteger fact = BigInteger.valueOf(1);
    for (int i = 1; i <= 8785856; i++)
        fact = fact.multiply(BigInteger.valueOf(i));
    System.out.println(fact);
}

Answer 2:

你可能要重新计算这一巨大的价值。 Wolfram Alpha的的逼近表明，它肯定会不适合在主内存中显示。

Answer 3:

此代码应该很好地工作： -

public class BigMath {
    public static String factorial(int n) {
        return factorial(n, 300);
    }

    private static String factorial(int n, int maxSize) {
        int res[] = new int[maxSize];
        res[0] = 1; // Initialize result
        int res_size = 1;

        // Apply simple factorial formula n! = 1 * 2 * 3 * 4... * n
        for (int x = 2; x <= n; x++) {
            res_size = multiply(x, res, res_size);
        }

        StringBuffer buff = new StringBuffer();
        for (int i = res_size - 1; i >= 0; i--) {
            buff.append(res[i]);
        }

        return buff.toString();
    }

    /**
     * This function multiplies x with the number represented by res[]. res_size
     * is size of res[] or number of digits in the number represented by res[].
     * This function uses simple school mathematics for multiplication.
     * 
     * This function may value of res_size and returns the new value of res_size.
     */
    private static int multiply(int x, int res[], int res_size) {
        int carry = 0; // Initialize carry.

        // One by one multiply n with individual digits of res[].
        for (int i = 0; i < res_size; i++) {
            int prod = res[i] * x + carry;
            res[i] = prod % 10; // Store last digit of 'prod' in res[]
            carry = prod / 10;  // Put rest in carry
        }

        // Put carry in res and increase result size.
        while (carry != 0) {
            res[res_size] = carry % 10;
            carry = carry / 10;
            res_size++;
        }

        return res_size;
    }

    /** Driver method. */
    public static void main(String[] args) {
        int n = 100;

        System.out.printf("Factorial %d = %s%n", n, factorial(n));
    }
}

Answer 4:

提示：使用BigInteger类，并准备给JVM大量的内存。 值8785856! 是一个非常大的数字。

Answer 5:

使用类BigInteger 。 （我不知道是否会即使如此巨大的整数工作）

Answer 6:

本博客文章解释了与Java的例子阶乘的BigInteger。

Answer 7:

Infinity是在一个特殊的保留值Double ，当你有超过一个的最大数量的一类double能容纳。

如果你希望你的代码工作，使用BigDecimal类，但考虑到输入数字，不要指望你的程序尽快完成执行的时候。

Answer 8:

如果不是天使用的BigInteger您的问题（8785856！）上述解决方案会从字面上采取的CPU小时的时间。 你需要确切的结果或将逼近足够？

有所谓的“数学方法英镑逼近 ”，它可以简单快速地计算了，下面是高斯帕的改进：

Answer 9:

 import java.util.*;
 import java.math.*;

class main
{
public static void main(String args[])
{
    Scanner sc= new Scanner(System.in);

        int i;
        int n=sc.nextInt();


      BigInteger fact = BigInteger.valueOf(1);

        for ( i = 1; i <= n; i++)
        {
            fact = fact.multiply(BigInteger.valueOf(i));
        }
        System.out.println(fact);

}
}

Answer 10:

试试这个：

import java.math.BigInteger;

public class LargeFactorial
{
    public static void main(String[] args)
    {
        int n = 50; 
    }
    public static BigInteger factorial(int n)
    {
       BigInteger result = BigInteger.ONE;
       for (int i = 1; i <= n; i++)
           result = result.multiply(new BigInteger(i + ""));
       return result;
    }
}

Answer 11:

    Scanner r = new Scanner(System.in);
    System.out.print("Input Number : ");
    int num = r.nextInt();
    int ans = 1;
    if (num <= 0) {
        ans = 0;
    }
    while (num > 0) {
        System.out.println(num + " x ");
        ans *= num--;
    }
    System.out.println("\b\b=" + ans);

Answer 12:

要真正摸清这个数字，你应该使用Python的功能，并尝试打开任务管理器，看看编译器多少内存占用的阶乘。 之后，你就会知道，有多少时间JVM是要采取，因为Python是数值计算的最佳语言。

Answer 13:

import java.util.Scanner;


public class factorial {
    public static void main(String[] args) {
        System.out.println("Enter the number : ");
        Scanner s=new Scanner(System.in);
        int n=s.nextInt();
        factorial f=new factorial();
        int result=f.fact(n);
        System.out.println("factorial of "+n+" is "+result);
    }
    int fact(int a)
    {
        if(a==1)
            return 1;
        else
            return a*fact(a-1);
    }

}

文章来源: Find factorial of large numbers in Java