私は、次のコードを最適化しようとしていたJava 8

Question

を使用して連続したサブリストの負の合計を見つける：私は、元のリストのすべての要素

ため startIndexから newIndex + 1に反復避けたい

private final static class SubarrayProcessorNegativeSumStrategy 
    implements SubarrayProcessorStrategy { 
    @Override public Integer apply(Integer[] array) { 
     final List<Integer> numbers = Arrays.asList(array); 
     return (int) IntStream.range(0, numbers.size()) 
      .map(index -> findNegativeSums(numbers, index)).sum(); 
    } 
    private Integer findNegativeSums(final List<Integer> numbers, 
            final Integer startIndex) { 
    final Integer numbersSize = numbers.size(); 
    if (startIndex < numbersSize) { 
     return (int) IntStream.range(startIndex, numbers.size()) 
     .map(newIndex -> numbers.subList(startIndex, newIndex + 1) 
     .stream().mapToInt(x -> x).sum()) 
     .filter(sum -> sum < 0).count(); 
    } else { 
     return 0; 
    } 
} 

を

numbers.subList(startIndex, newIndex + 1).stream().mapToInt(x -> x).sum()

私はこれをどのように達成することができますか？同じ結果を得るために改善を施すことができるのであれば？

あなたはStream APIを経由して、それを実装する場合は、List APIの迂回を経由する必要がないあなたに

よろしく、

Answer 1

ありがとうございます。さらに、«要素数の合計»あなたは、単一のflatMapストリーム操作を実行する場合は、すべての要素の合計数です：

private final static class SubarrayProcessorNegativeSumStrategy 
    implements SubarrayProcessorStrategy { 
    @Override public Integer apply(Integer[] array) { 
     return (int)IntStream.rangeClosed(0, array.length) 
      .flatMap(index -> IntStream.range(0, index) 
       .map(newIndex -> Arrays.stream(array,newIndex,index).mapToInt(x->x).sum()) 
       .filter(sum -> sum < 0)) 
      .count(); 
    } 
} 

これはまだネストされた反復の同じ時間の複雑さを持っています。実行時間を最適化したい場合は、ステートフルな操作がタスクにはるかに適していますが、これはStream APIの良いユースケースではありません。通常のループを使用すると、単純明快です：

private final static class SubarrayProcessorNegativeSumStrategy 
    implements SubarrayProcessorStrategy { 
    @Override public Integer apply(Integer[] array) { 
     int count=0; 
     for(int index = 0; index < array.length; index++) { 
      for(int newIndex = index, currSum = 0; newIndex < array.length; newIndex++) { 
       currSum += array[newIndex]; 
       if(currSum < 0) count++; 
      } 
     } 
     return count; 
    } 
} 

Answer 2

私が最初にあなたが気にすべてのインデックスを見つけることで、わずかに異なるアプローチを取りました。

3, 2, 1 
3, 2 
3 
2, 1 
2 
1 

をそしてちょうどsumにこれらのインデックスから値を収集する：配列[5,6,7]の例では、インデックスを生成します。

private static long applyMine(int[] array) { 
    return IntStream.range(0, array.length) 
      .flatMap(i -> IntStream.iterate(i, x -> x + 1) 
        .takeWhile(x -> x != array.length) 
        .map(m -> IntStream.iterate(array.length - i, x -> x - 1) 
          .takeWhile(x -> x >= array.length - m) 
          .map(x -> array[x - 1]) 
          .sum()) 
        .filter(s -> s < 0)) 
      .count(); 
}