add new problem 7.05

contest/src/main/java/com/github/contest/array/ArrayLeetcode.kt

@@ -1,5 +1,7 @@
 package com.github.contest.array
 
+import java.util.PriorityQueue
+
 
 /**
  * 1800. Maximum Ascending Subarray Sum
@@ -257,3 +259,39 @@ fun buildArray(nums: IntArray): IntArray {
     return new
 }
 
+/**
+ * 56. Merge Intervals
+ */
+
+fun merge(intervals: Array<IntArray>): Array<IntArray> {
+    if (intervals.size == 1) return intervals
+
+    val pq = PriorityQueue { a: IntArray, b: IntArray -> a[0] - b[0] }
+    val k = 2
+    var temp = IntArray(k)
+    val res = mutableListOf<IntArray>()
+
+    for (interval in intervals) {
+        pq.offer(interval)
+    }
+
+    val (start, end) = pq.poll()
+    temp[0] = start
+    temp[1] = end
+
+    while (pq.isNotEmpty()) {
+        val (start, end) = pq.poll()
+        if (temp[1] in start..end) temp[1] = end
+        else if (temp[1] < start) {
+            res.add(temp)
+            temp = IntArray(k)
+            temp[0] = start
+            temp[1] = end
+        }
+    }
+
+    res.add(temp)
+
+    return res.toTypedArray()
+}
+

contest/src/main/java/com/github/contest/array/ArrayProdVariant.kt

@@ -72,4 +72,52 @@ fun applyOperationsProdVariantII(nums: IntArray): IntArray {
     nums.fill(0, insertPos)
 
     return nums
-}
+}
+
+/**
+ * 1920. Build Array from Permutation
+ */
+
+fun buildArrayProdVariant(nums: IntArray): IntArray {
+    nums.forEachIndexed { index, _ ->
+        val new = nums[nums[index]] % nums.size
+        val prev = nums[index]
+        nums[index] = (new * nums.size) + prev
+    }
+    nums.forEachIndexed { index, _ ->
+        nums[index] /= nums.size
+    }
+
+    return nums
+}
+
+/**
+ * 56. Merge Intervals
+ * Prod Variant
+ */
+
+fun mergeProdVariantStage(intervals: Array<IntArray>): Array<IntArray> {
+    if (intervals.size == 1) return intervals
+
+    intervals.sortBy { it[0] }
+    val merged = mutableListOf<IntArray>()
+    var current = intervals[0]
+
+    intervals.drop(1).forEach {
+        if (current[1] in it[0]..it[1]) current[1] = maxOf(current[1], it[1])
+        else {
+            merged.add(current)
+            current = it
+        }
+    }
+
+    return merged.toTypedArray()
+}
+
+fun mergeProdVariantII(intervals: Array<IntArray>): Array<IntArray> =
+    intervals.sortedBy { it[0] }.fold(mutableListOf<IntArray>()) { merged, interval ->
+        merged.lastOrNull()?.takeIf { it[1] >= interval[0] }?.let {
+            it[1] = maxOf(it[1], interval[1])
+        } ?: merged.add(interval)
+        merged
+    }.toTypedArray()

contest/src/main/java/com/github/contest/slidingWindow/SlidingWindowLeetcode.kt

@@ -161,3 +161,47 @@ fun countSubArrayWithMaxElement(nums: IntArray, k: Int): Long {
 
     return count
 }
+
+/**
+ * 209. Minimum Size Subarray Sum
+ */
+
+fun minSubArrayLen(target: Int, nums: IntArray): Int {
+    var minLen = Int.MAX_VALUE
+    var sum = 0
+    var left = 0
+    var currentLen = 0
+
+    for (element in nums) {
+        sum += element
+        currentLen++
+        if (sum >= target) {
+            minLen = minOf(minLen, currentLen)
+            var localLen = minLen
+            while (sum >= target) {
+                if (sum == target) break
+                if (localLen == 1) return 1
+                if (sum - nums[left] < target) break
+                else {
+                    sum -= nums[left]
+                    localLen--
+                    left++
+                }
+            }
+            minLen = minOf(minLen, localLen)
+            currentLen = minOf(currentLen, localLen)
+        }
+
+
+        if (currentLen == minLen) {
+            sum -= nums[left]
+            left++
+            currentLen--
+        }
+    }
+
+    return when {
+        minLen == Int.MAX_VALUE -> 0
+        else -> minLen
+    }
+}