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

Question

Consider the following Accumulator class with a missing method

'prodA(int m)'

which is supposed to return the product of all elements of the array A if such product is less than or equal to m and return m otherwise.

For example if A is the array {2,4,3} then

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

(Hint: the length of an array A is given by A.length )

Insert the code for the body of the method prodA where marked.

---

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

You simply multiply the elements of the array A , then check if the sum is smaller than m , if so, you return it, otherwise you return m .

I won't show you a full solution, but computing the multiplication of the elements is extremely easy, you should have an int res = 1; and then multiply it by each element from the array and reassign the result to res (using a loop).

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

There are not many things to consider here, but three come to my mind:

• How to treat the empty array? I assume that the result should be 1 in this case, as it lends itself by being the neutral element of multiplication
• How large is the array? Might it be worth to implement an "early return"? That is, when the array contains 1000000 elements, and you notice that the result of multiplying the first 2 elements already is greater than the limit, you could already return this limit, and not waste time by performing the remaining 999998 multiplications (assuming that the array does not contains zeros!)
• How to structure the methods? I think that separating the computation of the product and the computation of the actual result, like return Math.min(limit, product(A)) with an appropriate product method that only has the single responsibility of computing a product of the elements of an array. However, this makes the "early return" impossible.

The "early return" could do something like this:

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;
}

while from a standpoint of reusability, something like this might be nicer:

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;
}