Added tasks 2750-2762

Author: ThanhNIT

src/main/kotlin/g2701_2800/s2750_ways_to_split_array_into_good_subarrays/Solution.kt

@@ -0,0 +1,26 @@
+package g2701_2800.s2750_ways_to_split_array_into_good_subarrays
+
+// #Medium #Array #Dynamic_Programming #Math
+// #2023_08_09_Time_916_ms_(100.00%)_Space_71.5_MB_(76.32%)
+
+class Solution {
+    fun numberOfGoodSubarraySplits(nums: IntArray): Int {
+        val res: MutableList<Int> = ArrayList()
+        val modulo = 1000000007L
+        for (i in nums.indices) {
+            if (nums[i] == 1) res.add(i)
+        }
+        var ans: Long = 0
+        if (res.isNotEmpty()) ans = 1
+        var kanishk = ans
+        for (i in res.size - 2 downTo 0) {
+            val leftInd = res[i]
+            val rightInd = res[i + 1]
+            val df = rightInd - leftInd
+            val mul = df.toLong() % modulo * kanishk % modulo % modulo
+            kanishk = mul
+            ans = mul
+        }
+        return ans.toInt()
+    }
+}

src/main/kotlin/g2701_2800/s2750_ways_to_split_array_into_good_subarrays/readme.md

@@ -0,0 +1,35 @@
+2750\. Ways to Split Array Into Good Subarrays
+
+Medium
+
+You are given a binary array `nums`.
+
+A subarray of an array is **good** if it contains **exactly** **one** element with the value `1`.
+
+Return _an integer denoting the number of ways to split the array_ `nums` _into **good** subarrays_. As the number may be too large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+A subarray is a contiguous **non-empty** sequence of elements within an array.
+
+**Example 1:**
+
+**Input:** nums = [0,1,0,0,1]
+
+**Output:** 3
+
+**Explanation:** There are 3 ways to split nums into good subarrays:
+- [0,1] [0,0,1] 
+- [0,1,0] [0,1]
+- [0,1,0,0] [1]
+
+**Example 2:**
+
+**Input:** nums = [0,1,0]
+
+**Output:** 1
+
+**Explanation:** There is 1 way to split nums into good subarrays: - [0,1,0]
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   `0 <= nums[i] <= 1`

src/main/kotlin/g2701_2800/s2751_robot_collisions/Solution.kt

@@ -0,0 +1,69 @@
+package g2701_2800.s2751_robot_collisions
+
+// #Hard #Array #Sorting #Stack #Simulation
+// #2023_08_09_Time_1049_ms_(100.00%)_Space_78.2_MB_(66.67%)
+
+import java.util.ArrayDeque
+
+class Solution {
+    fun survivedRobotsHealths(pos: IntArray, h: IntArray, dir: String): List<Int> {
+        val a = Array(pos.size) { IntArray(4) { 0 } }
+        for (i in pos.indices) {
+            a[i][0] = pos[i]
+            a[i][1] = h[i]
+            a[i][2] = if (dir[i] == 'R') 1 else 0
+            a[i][3] = i
+        }
+        a.sortWith(compareBy { it[0] })
+        val q = ArrayDeque<Int>()
+        for (i in a.indices) {
+            if (q.isEmpty() || a[i][2] == 1) {
+                q.push(i)
+            } else {
+                var prev = a[q.peek()]
+                if (prev[2] == 1) {
+                    if (a[i][1] == prev[1]) {
+                        q.pop()
+                        continue
+                    } else {
+                        while (true) {
+                            if (a[i][1] == prev[1]) {
+                                q.pop()
+                                break
+                            }
+                            if (prev[1] > a[i][1]) {
+                                prev[1] -= 1
+                                break
+                            } else {
+                                q.pop()
+                                a[i][1] -= 1
+                                if (q.isEmpty() || a[q.peek()][2] == 0) {
+                                    q.push(i)
+                                    break
+                                } else {
+                                    prev = a[q.peek()]
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    q.push(i)
+                }
+            }
+        }
+        val b = Array(q.size) { IntArray(2) { 0 } }
+        var j = 0
+        while (q.isNotEmpty()) {
+            val n = q.pop()
+            b[j][0] = a[n][1]
+            b[j][1] = a[n][3]
+            j++
+        }
+        b.sortWith(compareBy { it[1] })
+        val res = mutableListOf<Int>()
+        for (element in b) {
+            res.add(element[0])
+        }
+        return res
+    }
+}

src/main/kotlin/g2701_2800/s2751_robot_collisions/readme.md

@@ -0,0 +1,54 @@
+2751\. Robot Collisions
+
+Hard
+
+There are `n` **1-indexed** robots, each having a position on a line, health, and movement direction.
+
+You are given **0-indexed** integer arrays `positions`, `healths`, and a string `directions` (`directions[i]` is either **'L'** for **left** or **'R'** for **right**). All integers in `positions` are **unique**.
+
+All robots start moving on the line **simultaneously** at the **same speed** in their given directions. If two robots ever share the same position while moving, they will **collide**.
+
+If two robots collide, the robot with **lower health** is **removed** from the line, and the health of the other robot **decreases** **by one**. The surviving robot continues in the **same** direction it was going. If both robots have the **same** health, they are both removed from the line.
+
+Your task is to determine the **health** of the robots that survive the collisions, in the same **order** that the robots were given, i.e. final heath of robot 1 (if survived), final health of robot 2 (if survived), and so on. If there are no survivors, return an empty array.
+
+Return _an array containing the health of the remaining robots (in the order they were given in the input), after no further collisions can occur._
+
+**Note:** The positions may be unsorted.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2023/05/15/image-20230516011718-12.png)
+
+**Input:** positions = [5,4,3,2,1], healths = [2,17,9,15,10], directions = "RRRRR"
+
+**Output:** [2,17,9,15,10]
+
+**Explanation:** No collision occurs in this example, since all robots are moving in the same direction. So, the health of the robots in order from the first robot is returned, [2, 17, 9, 15, 10].
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2023/05/15/image-20230516004433-7.png)
+
+**Input:** positions = [3,5,2,6], healths = [10,10,15,12], directions = "RLRL"
+
+**Output:** [14]
+
+**Explanation:** There are 2 collisions in this example. Firstly, robot 1 and robot 2 will collide, and since both have the same health, they will be removed from the line. Next, robot 3 and robot 4 will collide and since robot 4's health is smaller, it gets removed, and robot 3's health becomes 15 - 1 = 14. Only robot 3 remains, so we return [14].
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2023/05/15/image-20230516005114-9.png)
+
+**Input:** positions = [1,2,5,6], healths = [10,10,11,11], directions = "RLRL"
+
+**Output:** []
+
+**Explanation:** Robot 1 and robot 2 will collide and since both have the same health, they are both removed. Robot 3 and 4 will collide and since both have the same health, they are both removed. So, we return an empty array, [].
+
+**Constraints:**
+
+*   <code>1 <= positions.length == healths.length == directions.length == n <= 10<sup>5</sup></code>
+*   <code>1 <= positions[i], healths[i] <= 10<sup>9</sup></code>
+*   `directions[i] == 'L'` or `directions[i] == 'R'`
+*   All values in `positions` are distinct

src/main/kotlin/g2701_2800/s2760_longest_even_odd_subarray_with_threshold/Solution.kt

@@ -0,0 +1,27 @@
+package g2701_2800.s2760_longest_even_odd_subarray_with_threshold
+
+// #Easy #Array #Sliding_Window #2023_08_09_Time_285_ms_(95.45%)_Space_46.8_MB_(31.82%)
+
+class Solution {
+    fun longestAlternatingSubarray(nums: IntArray, threshold: Int): Int {
+        var maxLength = 0
+        var i = 0
+        while (i < nums.size) {
+            if (nums[i] % 2 == 0 && nums[i] <= threshold) {
+                var length = 1
+                var j = i + 1
+                while (j < nums.size &&
+                    nums[j] <= threshold &&
+                    nums[j] % 2 != nums[j - 1] % 2
+                ) {
+                    length++
+                    j++
+                }
+                maxLength = maxLength.coerceAtLeast(length)
+                i = j - 1
+            }
+            i++
+        }
+        return maxLength
+    }
+}

src/main/kotlin/g2701_2800/s2760_longest_even_odd_subarray_with_threshold/readme.md

@@ -0,0 +1,57 @@
+2760\. Longest Even Odd Subarray With Threshold
+
+Easy
+
+You are given a **0-indexed** integer array `nums` and an integer `threshold`.
+
+Find the length of the **longest subarray** of `nums` starting at index `l` and ending at index `r` `(0 <= l <= r < nums.length)` that satisfies the following conditions:
+
+*   `nums[l] % 2 == 0`
+*   For all indices `i` in the range `[l, r - 1]`, `nums[i] % 2 != nums[i + 1] % 2`
+*   For all indices `i` in the range `[l, r]`, `nums[i] <= threshold`
+
+Return _an integer denoting the length of the longest such subarray._
+
+**Note:** A **subarray** is a contiguous non-empty sequence of elements within an array.
+
+**Example 1:**
+
+**Input:** nums = [3,2,5,4], threshold = 5
+
+**Output:** 3
+
+**Explanation:**
+
+In this example, we can select the subarray that starts at l = 1 and ends at r = 3 => [2,5,4]. This subarray satisfies the conditions.
+
+Hence, the answer is the length of the subarray, 3. We can show that 3 is the maximum possible achievable length.
+
+**Example 2:**
+
+**Input:** nums = [1,2], threshold = 2
+
+**Output:** 1
+
+**Explanation:**
+
+In this example, we can select the subarray that starts at l = 1 and ends at r = 1 => [2].
+
+It satisfies all the conditions and we can show that 1 is the maximum possible achievable length.
+
+**Example 3:**
+
+**Input:** nums = [2,3,4,5], threshold = 4
+
+**Output:** 3
+
+**Explanation:**
+
+In this example, we can select the subarray that starts at l = 0 and ends at r = 2 => [2,3,4].
+
+It satisfies all the conditions. Hence, the answer is the length of the subarray, 3. We can show that 3 is the maximum possible achievable length.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `1 <= nums[i] <= 100`
+*   `1 <= threshold <= 100`

src/main/kotlin/g2701_2800/s2761_prime_pairs_with_target_sum/Solution.kt

@@ -0,0 +1,37 @@
+package g2701_2800.s2761_prime_pairs_with_target_sum
+
+// #Medium #Array #Math #Enumeration #Number_Theory
+// #2023_08_10_Time_537_ms_(100.00%)_Space_54.2_MB_(46.15%)
+
+class Solution {
+    fun findPrimePairs(n: Int): List<List<Int>> {
+        val answer: MutableList<List<Int>> = ArrayList()
+        for (a in list) {
+            val other = n - a
+            if (other < n / 2 || a > n / 2) break
+            if (primes.contains(other)) answer.add(listOf(a, other))
+        }
+        return answer
+    }
+
+    companion object {
+        private val primes: HashSet<Int> = HashSet()
+        private val list: MutableList<Int> = ArrayList()
+
+        init {
+            val m = 1000001
+            val visited = BooleanArray(m)
+            for (i in 2 until m) {
+                if (!visited[i]) {
+                    primes.add(i)
+                    list.add(i)
+                    var j: Int = i
+                    while (j < m) {
+                        visited[j] = true
+                        j += i
+                    }
+                }
+            }
+        }
+    }
+}

src/main/kotlin/g2701_2800/s2761_prime_pairs_with_target_sum/readme.md

@@ -0,0 +1,39 @@
+2761\. Prime Pairs With Target Sum
+
+Medium
+
+You are given an integer `n`. We say that two integers `x` and `y` form a prime number pair if:
+
+*   `1 <= x <= y <= n`
+*   `x + y == n`
+*   `x` and `y` are prime numbers
+
+Return _the 2D sorted list of prime number pairs_ <code>[x<sub>i</sub>, y<sub>i</sub>]</code>. The list should be sorted in **increasing** order of <code>x<sub>i</sub></code>. If there are no prime number pairs at all, return _an empty array_.
+
+**Note:** A prime number is a natural number greater than `1` with only two factors, itself and `1`.
+
+**Example 1:**
+
+**Input:** n = 10
+
+**Output:** [[3,7],[5,5]]
+
+**Explanation:**
+
+In this example, there are two prime pairs that satisfy the criteria.
+
+These pairs are [3,7] and [5,5], and we return them in the sorted order as described in the problem statement.
+
+**Example 2:**
+
+**Input:** n = 2
+
+**Output:** []
+
+**Explanation:**
+
+We can show that there is no prime number pair that gives a sum of 2, so we return an empty array.
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>6</sup></code>

src/main/kotlin/g2701_2800/s2762_continuous_subarrays/Solution.kt

@@ -0,0 +1,31 @@
+package g2701_2800.s2762_continuous_subarrays
+
+// #Medium #Array #Heap_Priority_Queue #Sliding_Window #Ordered_Set #Queue #Monotonic_Queue
+// #2023_08_10_Time_492_ms_(100.00%)_Space_62.4_MB_(84.62%)
+
+import java.util.TreeMap
+
+class Solution {
+    fun continuousSubarrays(nums: IntArray): Long {
+        var left = 0
+        var right = 0
+        var total = 0L
+        val tree = TreeMap<Int, Int>()
+        val n = nums.size
+        while (right < n) {
+            if (!tree.containsKey(nums[right])) {
+                tree[nums[right]] = 0
+            }
+            tree[nums[right]] = tree[nums[right]]!! + 1
+            while (kotlin.math.abs(tree.lastKey() - nums[right]) > 2 || Math.abs(tree.firstKey() - nums[right]) > 2) {
+                val keyL = nums[left]
+                tree[keyL] = tree[keyL]!! - 1
+                if (tree[keyL] == 0) tree.remove(keyL)
+                left++
+            }
+            total += right - left + 1
+            right++
+        }
+        return total
+    }
+}