Question

如何获得具有Java特定限制的整数数组的乘积？

让我们说：

数组未排序
数组可以包含-99到99之间的任何数字。
指定的限制为1000.（maxProduct＆lt; = 1000）

e.g

int[] array = {-5,1,-1,0,10,-10,9,-2,1001};

int maxProduct = arr[0]*arr[2]*arr[4]*arr[5]*arr[6]*arr[7];

Answer 1

如果数组有负数，那么你也应该有一个负（最小）值......

您可以在没有流可用的版本中按元素交换数组元素......

int res = 1;
int max = 1000;
for(int i : array){
   res *= i;
   if(res>max) res = max;
}
System.out.println("Product: " +  res);

Answer 2

int max = 1000;
int res = 1;
for (int i : array) {
    if (i >= 0)
        res *= i;
    if (res >= max)
        res = max;
}

这将排除负数但接受0

Answer 3

OptionalInt reduce = Arrays.stream(array).
                     filter(i -> i != 0).
                     reduce((a, b) -> a * b > 1000 ? 1000 : a * b);

System.out.println(reduce.getAsInt());

您可以延长或删除过滤器。根据您的要求......

Answer 4

如果我做得对，你正在寻找一个具有给定限制下的最大产品的数组的子集，输出就像

arr[1]*arr[5]*arr[6]*arr[10]

是具有最大值的子集。产品

为了做到这一点，首先需要得到数组的powerset，即数组的所有可能子集，并计算每个子集的乘积，检查它是否是给定限制下的最大值。 Beleow就是一个例子：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

public class NewClass {

    public static void main(String[] args) {
        Integer[] array = {-5,1,-1,0,10,-10,9,-2,1001};
        List<Integer> list = Arrays.asList(array);
        Integer limit = 1000;

        List<List<Integer>> powerset = getPowerset(list);
        List<Integer> maxProdList = getMaxProduct(powerset,limit);
        Integer prod =1;
        for(Integer i : maxProdList){
           prod*=i; 
        }
        System.out.println("List: " + maxProdList );
        System.out.println("max product: " + prod );
    }

    //returns all possible subsets [[-5],[-5,1,9],[1,-1,1001][-5,1,-1,0,10] ... and so on]
    // see also http://stackoverflow.com/questions/1670862/obtaining-a-powerset-of-a-set-in-java
    public static List<List<Integer>> getPowerset(Collection<Integer> list) {
        List<List<Integer>> ps = new ArrayList<>();
        ps.add(new ArrayList<>());
        for (Integer item : list) {
          List<List<Integer>> newPs = new ArrayList<>();

          for (List<Integer> subset : ps) {
            newPs.add(subset);
            List<Integer> newSubset = new ArrayList<>(subset);
            newSubset.add(item);
            newPs.add(newSubset);
          }
          ps = newPs;
        }
        return ps;
    }

    public static List<Integer> getMaxProduct(List<List<Integer>> listOfLists, Integer limit){
        List<Integer> listOfMax = new ArrayList<>();
        Integer max = 1;
        for(List<Integer> list : listOfLists){
            Integer prod =1;
            for(Integer i : list){
               prod*=i; 
            }
            if(prod>max && prod<=limit){
                max=prod;
                listOfMax = list;
            }
        }
        return listOfMax;        
    }
}

Answer 5

这是一个以伪代码粗糙的想法。我没有测试过它：

maxProduct <- 1000
maxRand <- 99
lowLimit <- 5

repeat
  num <- random(1, maxRand)
  add num to array
  maxProduct <- maxProduct DIV num
  maxRand <- minimum(maxRand, maxProduct)
until (maxRand < lowLimit)

if (maxRand > 0) add maxRand to array

我使用DIV进行整数除法，并将maxRand添加到数组中，以使最终产品更接近原始maxProduct。您可以根据需要调整lowLimit。我感觉很懒，所以我没有打扰负数，可能选择2,4或6个数组元素并切换它们的符号。只要存在偶数个负数，那么最终产品将是正数。

具有限制的整数数组的乘积

5 个答案: