在java中使用数组计算50的阶乘

Question

我是java的初学者。 我有作业写一个完整的程序，计算使用数组的50阶乘。 我不能使用biginteger之类的任何方法。 我只能使用数组，因为我的教授希望我们理解背后的逻辑，我猜... 但是，他并没有真正教会我们数组的细节，所以我在这里非常困惑。

基本上，我试图划分大数字，并将其放入数组插槽。因此，如果第一个数组获得235，我可以将其分开并提取数字并将其放入一个数组插槽中。然后，放置下一个数组插槽。并重复这个过程，直到我得到结果（这是50阶乘，这是一个巨大的数字..）

我试图理解背后的逻辑是什么，但我真的无法弄清楚..到目前为止我有这个想法。

import java.util.Scanner; 
class Factorial 
{ 
    public static void main(String[] args) 
    { 
     int n; 
     Scanner kb = new Scanner(System.in); 
     System.out.println("Enter n"); 
     n = kb.nextInt(); 
     System.out.println(n +"! = " + fact(n)); 
    } 

    public static int fact(int n) 
    { 
     int product = 1; 
     int[] a = new int[100]; 
     a[0] = 1; 



     for (int j = 2; j < a.length; j++) 
     { 
      for(; n >= 1; n--) 
      { 
       product = product * n; 

       a[j-1] = n; 
       a[j] = a[j]/10; 
       a[j+1] = a[j]%10; 

      } 

     } 
     return product; 
    } 
} 

不过，这并不表明我的50 阶乘它显示我作为0的结果，所以很显然，它不工作。

我想使用一种方法（事实（）），但我不知道这是正确的方法。 我的教授提到有关使用operator /和％将数字重复分配给数组的下一个插槽。 所以我试图用这个作业。

有没有人有这个作业的想法？ 请帮帮我！

对于令人困惑的指令感到抱歉...我也很困惑，所以请原谅我。

FYI：50阶乘是30414093201713378043612608166064768844377641568960512000000000000

Answer 1

试试这个。

static int[] fact(int n) { 
    int[] r = new int[100]; 
    r[0] = 1; 
    for (int i = 1; i <= n; ++i) { 
     int carry = 0; 
     for (int j = 0; j < r.length; ++j) { 
      int x = r[j] * i + carry; 
      r[j] = x % 10; 
      carry = x/10; 
     } 
    } 
    return r; 
} 

和

int[] result = fact(50); 
int i = result.length - 1; 
while (i > 0 && result[i] == 0) 
    --i; 
while (i >= 0) 
    System.out.print(result[i--]); 
System.out.println(); 
// -> 30414093201713378043612608166064768844377641568960512000000000000 

Answer 2

怎么样：

int[] arrayOfFifty = new int[50]; 
//populate the array with 1 to 50 
for(int i = 1; i < 51; i++){ 
    arrayOfFifty[i-1] = i; 
} 

//perform the factorial 
long result = 1; 
for(int i = 0; i < arrayOfFifty.length; i++){ 
    result = arrayOfFifty[i] * result; 
} 

没有测试这一点。不知道这个数字有多大，以及它是否会因数字大小而导致错误。

已更新。数组使用“.length”来测量大小。

我现在更新结果为长数据类型，并返回以下内容 - 显然是不正确的。这是一个庞大的数字，我不确定你的教授想要了解什么。 -3258495067890909184

Answer 3

如何：

public static BigInteger p(int numOfAllPerson) { 

    if (numOfAllPerson < 0) { 

     throw new IllegalArgumentException(); 

    } 

    if (numOfAllPerson == 0) { 

     return BigInteger.ONE; 

    } 

    BigInteger retBigInt = BigInteger.ONE; 

    for (; numOfAllPerson > 0; numOfAllPerson--) { 

     retBigInt = retBigInt.multiply(BigInteger.valueOf(numOfAllPerson)); 

    } 

    return retBigInt; 

} 

Answer 4

请记得数学乘法是如何工作的基本水平？

2344 
X 34 

= (2344*4)*10^0 + (2344*3)*10^1 = ans 


2344 
X334 

= (2344*4)*10^0 + (2344*3)*10^1 + (2344*3)*10^2= ans 

因此，对于m位X n位数字，您需要n个字符串数组列表。

每次将每个数字乘以m。并存储它。

在每一步之后，您将追加0,1,2，n-1尾随零（s）到该字符串。

最后，总结n列出的所有字符串。你知道该怎么做。

所以到这一点，你知道m * n个

现在是很容易计算1 * .......... * 49 * 50。

Answer 5

她是我的结果：

50 factorial - 30414093201713378043612608166064768844377641568960512000000000000 

而这里的代码。我硬编码了一个100位数字的数组。打印时，我跳过前导零。

public class FactorialArray { 

    public static void main(String[] args) { 
     int n = 50; 
     System.out.print(n + " factorial - "); 

     int[] result = factorial(n); 

     boolean firstDigit = false; 
     for (int digit : result) { 
      if (digit > 0) { 
       firstDigit = true; 
      } 

      if (firstDigit) { 
       System.out.print(digit); 
      } 
     } 

     System.out.println(); 
    } 

    private static int[] factorial(int n) { 
     int[] r = new int[100]; 
     r[r.length - 1] = 1; 
     for (int i = 1; i <= n; i++) { 
      int carry = 0; 
      for (int j = r.length - 1; j >= 0; j--) { 
       int x = r[j] * i + carry; 
       r[j] = x % 10; 
       carry = x/10; 
      } 
     } 
     return r; 
    } 

}