Question

考虑以下具有缺失方法的Accumulator类

＆＃39; prodA（int m）＆＃39;

应该返回数组A的所有元素的乘积如果此类产品小于或等于m，则以其他方式返回。

例如，如果A是数组{2,4,3}，那么

prodA(2) will return 2
prodA(0) will return 0
prodA(50) will return 24

（提示：数组A的长度由A.length给出）

插入方法prodA的主体的代码标记

public class Accumulator {
    private int[] A;

    public Accumulator(int[] X) {
        A= new int[X.length];
        for (int i=0; i<X.length; i++)
            A[i] = X[i];
    }

    public int prodA(int m) {
        // insert your code here
    }

}

Answer 1

您只需将数组A的元素相乘，然后检查总和是否小于m，如果是，则返回，否则返回m。

我不会向您展示完整的解决方案，但计算元素的乘法非常简单，您应该有一个int res = 1;，然后将它乘以数组中的每个元素并将结果重新分配给res（使用循环）。

Answer 2

int prod=1;
for(int i:A){
  prod=prod*i;
}
if(prod<m)
 return prod;
else
 return m;

Answer 3

    public int prodA(int m) {
      int p=1;
      for(int i=0;i<A.lenght.i++){
        p=p*A[i];
      }
      if(p<=m)
        return p;
      else
       return m;
    }

Answer 4

int product=1;      
for(int num:A) {
           product=product*num;
        }
        return (product<=m)?product:m;

Answer 5

这里没有太多可以考虑的事情，但我想到了三个：

如何处理空数组？我假设在这种情况下结果应该是1，因为它本身就是乘法的中性元素
阵列有多大？可能值得实施“早期回归”吗？也就是说，当数组包含1000000个元素，并且您注意到前两个元素的乘积结果已经大于限制时，您可能已经返回此限制，而不是通过执行剩余的999998乘法来浪费时间（假设数组不包含零！）
如何构建方法？我认为将产品的计算和实际结果的计算分开，例如return Math.min(limit, product(A))与适当的product方法，只有单一责任计算产品数组的元素。然而，这使得“早期回归”变得不可能。

“早期回归”可以做到这样的事情：

public int prodA(int m)
{
    int product = 1;
    for (int i = 0; i < A.length; i++)
    {
        product *= A[i];
        if (product >= m)
        {
            return m;
        }
    }
    return product;
}

从可重用性的角度来看，这样的事情可能会更好：

public int prodA(int m)
{
    return Math.min(m, product(A));
}

private static int product(int array[] )
{
    int product = 1;
    for (int i = 1; i < array.length; i++)
    {
        product *= array[i];
    }
    return product;
}

在阵列产品输出中需要帮助

5 个答案: