Java 超过整数最大值的解决方案？

你好，亲爱的社区

我已经想了很长时间了，但似乎找不到解决办法

我有我的

int[][]bino=new int[15][]

，其中我计算帕斯卡金字塔的前15行，不允许更改类型（不允许双精度、长型等）

我们知道12所学校的教师人数是479001600

int的最大值是2147483647，因此fac（12）仍然适合于该值

现在，对于最后3行，它变得复杂了

Fac（13）是6227020800，对于int来说太大了

因此，对于第13、14和15行，它不会显示正确的数字 （因为6227020800 mod 2147483647=1932053506，这意味着在我的示例中fac（13）=1932053506）

问题是，是否有一种方法可以在不改变

int[]]bino=new int[15][]

）中字段类型的情况下，以某种方式显示正确的数字。其他任何事情都可以改变

public static void main(String args[])
{

    int[][] bino = new int[15][]; //Create 2d array for pascal pyramid
    for(int i = 0; i < bino.length;i++)
      for(int j = 0; j < bino[i].length;j++)
        {
           binos[i][j] = nOverk(i,j)
        }

}

public int nOverk(int n, int k)
{
   return(fac(n) / (fac(k) * fac((n-k))));
}
public int fac(int z) //Calculats the faculty of a number
{
   int res = 1;

   if(z == 0 || z == 1)
      return 1;

   for(int i = 2; i <= z; i++)
      res *= i;
   return res;
}

publicstaticvoidmain（字符串参数[]）
{
int[][]bino=new int[15][]；//为帕斯卡金字塔创建二维数组
for（int i=0；i对于（int i=2；i而言，简单的解决方案是使用
long
，但是您可以通过计算效率更高的
fac（a）/fac（b）
来使用
int
来计算更大的数字（并节省工作量）

public static void main(String... args) {
    int[][] bino = new int[15][]; //Create 2d array for pascal pyramid
    for (int i = 0; i < bino.length; i++) {
        bino[i] = new int[i + 1];
        for (int j = 0; j < i + 1; j++) {
            bino[i][j] = nOverk(i, j);
        }
    }
}

static int nOverk(int n, int k) {
    int min = Math.min(k, n - k);
    int max = Math.max(k, n - k);
    return fac(n, max) / fac(min, 1);
}

static int fac(int hi, int lo) {
    if (hi == 0 || hi == 1)
        return 1;

    int res = 1;
    for (int i = lo + 1; i <= hi; i++)
        res *= i;
    return res;
}

publicstaticvoidmain（字符串…参数）{
int[][]bino=new int[15][]；//为帕斯卡金字塔创建二维数组
for（int i=0；i对于（int i=lo+1；i而言，简单的解决方案是使用
long
，但是您可以通过计算效率更高的
fac（a）/fac（b）
来使用
int
来计算更大的数字（并节省工作量）

public static void main(String... args) {
    int[][] bino = new int[15][]; //Create 2d array for pascal pyramid
    for (int i = 0; i < bino.length; i++) {
        bino[i] = new int[i + 1];
        for (int j = 0; j < i + 1; j++) {
            bino[i][j] = nOverk(i, j);
        }
    }
}

static int nOverk(int n, int k) {
    int min = Math.min(k, n - k);
    int max = Math.max(k, n - k);
    return fac(n, max) / fac(min, 1);
}

static int fac(int hi, int lo) {
    if (hi == 0 || hi == 1)
        return 1;

    int res = 1;
    for (int i = lo + 1; i <= hi; i++)
        res *= i;
    return res;
}

publicstaticvoidmain（字符串…参数）{
int[][]bino=new int[15][]；//为帕斯卡金字塔创建二维数组
for（int i=0；i对于（inti=lo+1；iAFAICT，您仅使用resp.need
fac（）
for
nOverk（）
。在术语
fac（n）/（fac（k）*fac（（n-k）））
中，您可以取消某些因素，将临时值保持在允许范围内

例如，您只需计算
（4*3）/（2*1）
，而不是
nOverk（4,2）=4*3*2*1/（（2*1）*（2*1））
。在某些情况下，这可能没有帮助，但我认为任务是以这种方式定义的，因此它会有所帮助

public int nOverk(int n, int k)
{
    return (lim_fac(n, k) / lim_fac(k, k));
}

private int lim_fac(int z, int n) //Calculats the "limited" faculty of a number, by multiplying n factors.
{
   int res = 1;

   if (n == 0) {
      return 1;
   }

   if (n == 1) {
      return z;
   }

   for (int i = z - n + 1; i <= z; i++) {
      res *= i;
   }

   return res;
}

public int nOverk（int n，int k）
{
返回（lim_fac（n，k）/lim_fac（k，k））；
}
private int lim_fac（int z，int n）//将n个因子相乘，计算一个数的“有限”能力。
{
int res=1；
如果（n==0）{
返回1；
}
如果（n==1）{
返回z；
}
对于（inti=z-n+1；iAFAICT，您仅使用resp.need
fac（）
for
nOverk（）
。在术语
fac（n）/（fac（k）*fac（（n-k）））
中，您可以取消某些因素，将临时值保持在允许范围内

例如，您只需计算
（4*3）/（2*1）
，而不是
nOverk（4,2）=4*3*2*1/（（2*1）*（2*1））
。在某些情况下，这可能没有帮助，但我认为任务是以这种方式定义的，因此它会有所帮助

public int nOverk(int n, int k)
{
    return (lim_fac(n, k) / lim_fac(k, k));
}

private int lim_fac(int z, int n) //Calculats the "limited" faculty of a number, by multiplying n factors.
{
   int res = 1;

   if (n == 0) {
      return 1;
   }

   if (n == 1) {
      return z;
   }

   for (int i = z - n + 1; i <= z; i++) {
      res *= i;
   }

   return res;
}

public int nOverk（int n，int k）
{
返回（lim_fac（n，k）/lim_fac（k，k））；
}
private int lim_fac（int z，int n）//将n个因子相乘，计算一个数的“有限”能力。
{
int res=1；
如果（n==0）{
返回1；
}
如果（n==1）{
返回z；
}
对于帕斯卡三角形中的（inti=z-n+1；i，每个数字都是其正上方两个数字的总和。如果任务只是打印前15行，则不需要使用阶乘

public static void main(String[] args) { 
    int n = 15;
    int[][] pascal  = new int[n+1][];

    // initialize first row
    pascal[1] = new int[1+2];
    pascal[1][1] = 1;

    // fill in Pascal's triangle
    for (int i = 2; i <= n; i++) {
        pascal[i] = new int[i+2];
        for (int j = 1; j < pascal[i].length - 1; j++)
            pascal[i][j] = pascal[i-1][j-1] + pascal[i-1][j];
    }

    // print results
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j < pascal[i].length - 1; j++) {
            System.out.print(pascal[i][j] + " ");
        }
        System.out.println();
    }
} 

publicstaticvoidmain（字符串[]args）{
int n=15；
int[][]帕斯卡=新int[n+1][]；
//初始化第一行
帕斯卡[1]=新整数[1+2]；
帕斯卡[1][1]=1；
//填充帕斯卡三角形
对于帕斯卡三角形中的（inti=2；i，每个数字都是其正上方两个数字的总和。如果任务只是打印前15行，则不需要使用阶乘

public static void main(String[] args) { 
    int n = 15;
    int[][] pascal  = new int[n+1][];

    // initialize first row
    pascal[1] = new int[1+2];
    pascal[1][1] = 1;

    // fill in Pascal's triangle
    for (int i = 2; i <= n; i++) {
        pascal[i] = new int[i+2];
        for (int j = 1; j < pascal[i].length - 1; j++)
            pascal[i][j] = pascal[i-1][j-1] + pascal[i-1][j];
    }

    // print results
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j < pascal[i].length - 1; j++) {
            System.out.print(pascal[i][j] + " ");
        }
        System.out.println();
    }
} 

publicstaticvoidmain（字符串[]args）{
int n=15；
int[][]帕斯卡=新int[n+1][]；
//初始化第一行
帕斯卡[1]=新整数[1+2]；
帕斯卡[1][1]=1；
//填充帕斯卡三角形
对于（int i=2；i in
long
可能存储比int更大的值，或者我发现建议使用
long
数据类型，如果可能，如果不可能，则使用biginteger-请参阅in
long
可能存储比int更大的值，或者我发现建议使用
long
数据类型，如果可能，则使用big整数-这可能是目前为止最好的答案，应该是公认的答案。这可能是目前为止最好的答案，应该是公认的答案。