產品整數數組與限制

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個陣列元素並切換其符號。只要有偶數的底片，那麼最終的產品就會是正面的。