マージソートされたリストを反復処理

bstapies：

ここに私の問題は、次のとおりです。

現在の年の日数は365 Aカバレッジに1の番号が付けられ、カバレッジ開始と終了/用語日と日付の範囲として定義されているとします。例：Cov(1, 31)人は、今年の月のための何かのために覆われていることを意味します。

問題：人のためのカバレッジデータのシリーズを考えると、我々は最も長い連続的にカバーを見つける必要があります。カバレッジは、カバレッジおよび/またはギャップをオーバーラップ有していてもよいです。（与えられたコードはScalaであり、私は解決するためにJavaを使用しました）。

class Cov(eff: Int, term: Int)
    val coverages = List(Cov(1,20), Cov(21,30), Cov(15,25), Cov(28,40), Cov(50, 60), Cov(61,200))

最長の用語を印刷するには、それを反復処理し、私はすべて間違ってこの質問に近づいている可能性がありますが、私は元の配列をソートするためにマージソートを使用していたし、その後。私のマージは私のリストをソートします。これは私が欲しかったものです。しかし、私は最も長い連続的にカバーを見つけるために移動する方法に問題が生じています。私は失われていますので、それはちょうど最後のインデックスに最後のインデックスと第二の印刷されないであろう。

public class Cov {

    private int eff;
    private int term;

    public Cov(int eff, int term) {
        this.eff = eff;
        this.term = term;
    }

    public static void merge(int[] coverage, int eff, int mid, int term) {
        // Creating temporary subarrays
        int leftArray[] = new int[mid - eff + 1];
        int rightArray[] = new int[term - mid];

        // Copying our subarrays into temporaries
        for (int i = 0; i < leftArray.length; i++)
            leftArray[i] = coverage[eff + i];
        for (int i = 0; i < rightArray.length; i++)
            rightArray[i] = coverage[mid + i + 1];

        // Iterators containing current index of temp subarrays
        int leftIndex = 0;
        int rightIndex = 0;

        // Copying from leftArray and rightArray back into array
        for (int i = eff; i < term + 1; i++) {
            // If there are still uncopied elements in R and L, copy minimum of the two
            if (leftIndex < leftArray.length && rightIndex < rightArray.length) {
                if (leftArray[leftIndex] < rightArray[rightIndex]) {
                   coverage[i] = leftArray[leftIndex];
                   leftIndex++;
                } else {
                    coverage[i] = rightArray[rightIndex];
                    rightIndex++;
                }
            } else if (leftIndex < leftArray.length) {
                // If all elements have been copied from rightArray, copy rest of leftArray
                coverage[i] = leftArray[leftIndex];
                leftIndex++;
            } else if (rightIndex < rightArray.length) {
                // If all elements have been copied from leftArray, copy rest of rightArray
                coverage[i] = rightArray[rightIndex];
                rightIndex++;
            }
        }
    }

    public static void mergeSort(int[] coverage, int eff, int term) {
        if (term <= eff) return;

        int mid = (eff + term) / 2;
        mergeSort(coverage, eff, mid);
        mergeSort(coverage, mid + 1, term);
        merge(coverage, eff, mid, term);
    }

    public static void main(String[] args) {
        List<Integer> coverages = new ArrayList<>();
        int coverage[] = { 1, 20, 21, 30, 15, 25, 28, 40, 50, 60, 61, 200 };
        merge(coverage, 0, 5, 11);
        System.out.println(Arrays.toString(coverage));

            for (int i = 0; i < coverage.length - 1; i++) {

            }
        }
    }

アンドレアス：

必要に応じて交換/拡張、反復は、リストを最長の継続的なカバレッジを見つけ、現在のカバレッジ期間を追跡するには。

var coverages = List.of(new Cov(1,20), new Cov(21,30), new Cov(15,25),
        new Cov(28,40), new Cov(50, 60), new Cov(61,200));

// Sort coverage periods by start value (eff)
//   (streaming into new list since original list is immutable)
coverages = coverages.stream().sorted(Comparator.comparingInt(Cov::getEff))
        .collect(Collectors.toList());

// Iterate coverage periods and find length of longest continuously covered period
int currEff = -1, currTerm = -1, maxLen = 0;
for (Cov cov : coverages) {
    if (cov.getEff() > currTerm + 1) { // Replace current coverage period if gap detected
        currEff = cov.getEff();
        currTerm = cov.getTerm();
    } else if (currTerm < cov.getTerm()) { // Extend current coverage period if needed
        currTerm = cov.getTerm();
    }
    // Update max if current coverage period is longer than any seen so far
    if (currTerm - currEff >= maxLen)
        maxLen = currTerm - currEff + 1;
}

System.out.println(maxLen); // prints: 151

class Cov {
    private final int eff;
    private final int term;
    public Cov(int eff, int term) {
        this.eff = eff;
        this.term = term;
    }
    public int getEff() {
        return this.eff;
    }
    public int getTerm() {
        return this.term;
    }
    @Override
    public String toString() {
        return "Cov(" + this.eff + "," + this.term + ")";
    }
}