产品整数数组与限制

Question

的我怎样才能得到一个整数数组的产品，在Java中的特定的限制？

比方说：

• 阵列未排序
• 阵列可以包含任何数量的从-99到99
• 指定的限制是1000（maxProduct < = 1000）

如

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

如果数组有负号，那么你应该有一个负的（最低）值太...

您可以通过interate在没有流是avaliable版本元素的数组元素...

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] 

是集最大。产品。

为了做到这一点，你需要先得到你的阵列，您阵即，所有可能的子集的幂，并计算每个子集检查的产品，如果它是在一个给定的限制最大。 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个阵列元素并切换其符号。只要有偶数的底片，那么最终的产品就会是正面的。