Java：包含二项式系数计算的表达式

任务是为输入的自然数计算表达式

我知道我应该在这里计算二项式系数，对吗？

我还知道（-1）^p决定这个数组是递减还是递增，但我不知道如何在代码中使用p 我不太确定如何把它放在一起，这是我到目前为止提出的，它真的没有什么特别的，因为我仍然无法理解如何在程序中编写它

public static int calculateExpression(int n, int k,int p) {

      if(k<0 || n<k)
         {
             return 0;
         }
    // Find factorial of n

    int n_fac = 1;
        for (int j = 1; j <= n; j++) {
            n_fac = n_fac * j;

        }

    // Find factorial of k

    int k_fac = 1;
        for(int i = 1; i<=k; i++) {
            k_fac = k_fac * i;

        }

        // Find n-k fac
        int n_k = n-k;
        int n_k_fac = 1;
            for(int l = 1; l<=n_k;l++) {
                n_k_fac*=l;
            }

        //      n/k = n!/k!(n-k)!

        double resultOf_n_kDivision = n_fac/k_fac*n_k_fa;

    System.out.println(resultOf_n_kDivision);
    return n_k_fac;



}

publicstaticintcalculateexpression（intn，intk，intp）{
如果（k使用抽象来更好地解决问题；定义
fac
和
over
。
那么问题就变成了：

public static int calculateExpression(int n, int k,int p) {
    int sum = 0;
    int minus1toP = 1;
    for (int i = 0; i <= p; i++) {
        sum += minus1toP * over(n, ...);
        minus1toP = -minus1toP;
    }
    return sum;
}

static int over(int n, int k) {
    return fac(n) / fac(k) / fac(n - k);
}

static int fac(int n) {
    int f = 1;
    for(int i = 2; i <= n; i++) {
        f *= i;
    }
    return f;
}

publicstaticintcalculateexpression（intn，intk，intp）{
整数和=0；
int减1top=1；
对于（inti=0；i我没有真正理解你的问题，但是你可以用这个

    public static double combination(int n, int k)
    {
        double nFactorial = getFactorialFromNToK(n, k);
        double kFactorial = getFactorialFromNToK(k, 1);

        return nFactorial / kFactorial;
    }

    public static double getFactorialFromNToK(double n, double k)
    {
        double factorial = 1;

        for (; n - k + 1 > 0; n--)
        {
            factorial *= n;
        }

        return factorial;
    }

这是nCk对二项展开式中某项系数的评估

如果nCn是展开式中的一个项，那么它会收敛，如果它不是展开式中的项，那么它不会收敛。因此，如果它是一个自然数展开式，那么它将始终收敛。
阶乘函数是一个增长非常快的函数，因此单独计算分子和分母可能不是一个好主意，因为它y即使是相对较小的
n值也会导致溢出

让我们看看计算系数的迭代方法：


我们发现，如果我们知道行的当前系数，我们可以计算该行的下一个系数。因此，我们可以增量计算
S
中的每个项，而不必担心溢出问题

static int calculateExpression(int n, int k, int p)
{
   // first term of the row is (n, 0) = 1
   int binom = 1;

   // Iteratively find (n, k)
   for (int i = 0; i < k; i++)
      binom = (binom * (n - i)) / (i + 1);

   // sum the series
   int S = binom;
   for (int i = 0; i < p; i++) {
      // "trick": multiply with a minus sign each time to flip the sign
      binom = (-binom * (n - k - i)) / (k + i + 1);
      S += binom;
   }

   return S;
}

正如您所看到的，这两个函数在最后一行使用
n=15
之前是一致的，因为
15！=1307674368000
远大于大多数Java实现中的最大正值
int
（32位）.
一个更好的解决方案是使用函数而不是阶乘。这是计算阶乘的更有效的方法。自然对数意味着除以大的数字将不会有太大的问题。
您的代码出了什么问题？或者您的问题是什么？我唯一能做的就是计算二项式系数。我不知道如何计算处理问题的其余部分。你说的PYO是什么意思？你没有解释什么是
p
，但是如果它是一个整数，那么y=（-1）**p非常简单：如果p是奇数，那么y=-1；如果p是偶数，那么y=1。我认为做简单的事情并使用阶乘是个坏主意。更好的解决方案是LNGAMA函数。
n   k   p | orig  new
----------------------
5   3   2 | 6     6
10  4   1 | -42   -42
12  3   7 | 44    44
15  8   6 | 3433  8     // integer overflow occurred with the original method