Added tasks 3658-3661

Author: javadev

src/main/kotlin/g3601_3700/s3658_gcd_of_odd_and_even_sums/Solution.kt

@@ -0,0 +1,9 @@
+package g3601_3700.s3658_gcd_of_odd_and_even_sums
+
+// #Easy #Weekly_Contest_464 #2025_08_25_Time_0_ms_(100.00%)_Space_40.78_MB_(100.00%)
+
+class Solution {
+    fun gcdOfOddEvenSums(n: Int): Int {
+        return if (n < 0) -n else n
+    }
+}

src/main/kotlin/g3601_3700/s3658_gcd_of_odd_and_even_sums/readme.md

@@ -0,0 +1,42 @@
+3658\. GCD of Odd and Even Sums
+
+Easy
+
+You are given an integer `n`. Your task is to compute the **GCD** (greatest common divisor) of two values:
+
+*   `sumOdd`: the sum of the first `n` odd numbers.
+    
+*   `sumEven`: the sum of the first `n` even numbers.
+    
+
+Return the GCD of `sumOdd` and `sumEven`.
+
+**Example 1:**
+
+**Input:** n = 4
+
+**Output:** 4
+
+**Explanation:**
+
+*   Sum of the first 4 odd numbers `sumOdd = 1 + 3 + 5 + 7 = 16`
+*   Sum of the first 4 even numbers `sumEven = 2 + 4 + 6 + 8 = 20`
+
+Hence, `GCD(sumOdd, sumEven) = GCD(16, 20) = 4`.
+
+**Example 2:**
+
+**Input:** n = 5
+
+**Output:** 5
+
+**Explanation:**
+
+*   Sum of the first 5 odd numbers `sumOdd = 1 + 3 + 5 + 7 + 9 = 25`
+*   Sum of the first 5 even numbers `sumEven = 2 + 4 + 6 + 8 + 10 = 30`
+
+Hence, `GCD(sumOdd, sumEven) = GCD(25, 30) = 5`.
+
+**Constraints:**
+
+*   `1 <= n <= 1000`

src/main/kotlin/g3601_3700/s3659_partition_array_into_k_distinct_groups/Solution.kt

@@ -0,0 +1,18 @@
+package g3601_3700.s3659_partition_array_into_k_distinct_groups
+
+// #Medium #Weekly_Contest_464 #2025_08_25_Time_96_ms_(100.00%)_Space_93.60_MB_(100.00%)
+
+class Solution {
+    fun partitionArray(nums: IntArray, k: Int): Boolean {
+        val mpp = HashMap<Int, Int>()
+        for (x in nums) {
+            mpp.put(x, mpp.getOrDefault(x, 0) + 1)
+        }
+        for (count in mpp.values) {
+            if (count > nums.size / k) {
+                return false
+            }
+        }
+        return nums.size % k == 0
+    }
+}

src/main/kotlin/g3601_3700/s3659_partition_array_into_k_distinct_groups/readme.md

@@ -0,0 +1,58 @@
+3659\. Partition Array Into K-Distinct Groups
+
+Medium
+
+You are given an integer array `nums` and an integer `k`.
+
+Your task is to determine whether it is possible to partition all elements of `nums` into one or more groups such that:
+
+*   Each group contains **exactly** `k` **distinct** elements.
+*   Each element in `nums` must be assigned to **exactly** one group.
+
+Return `true` if such a partition is possible, otherwise return `false`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4], k = 2
+
+**Output:** true
+
+**Explanation:**
+
+One possible partition is to have 2 groups:
+
+*   Group 1: `[1, 2]`
+*   Group 2: `[3, 4]`
+
+Each group contains `k = 2` distinct elements, and all elements are used exactly once.
+
+**Example 2:**
+
+**Input:** nums = [3,5,2,2], k = 2
+
+**Output:** true
+
+**Explanation:**
+
+One possible partition is to have 2 groups:
+
+*   Group 1: `[2, 3]`
+*   Group 2: `[2, 5]`
+
+Each group contains `k = 2` distinct elements, and all elements are used exactly once.
+
+**Example 3:**
+
+**Input:** nums = [1,5,2,3], k = 3
+
+**Output:** false
+
+**Explanation:**
+
+We cannot form groups of `k = 3` distinct elements using all values exactly once.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>5</sup></code>
+*   `1 <= k <= nums.length`

src/main/kotlin/g3601_3700/s3660_jump_game_ix/Solution.kt

@@ -0,0 +1,89 @@
+package g3601_3700.s3660_jump_game_ix
+
+// #Medium #Weekly_Contest_464 #2025_08_25_Time_205_ms_(100.00%)_Space_89.04_MB_(100.00%)
+
+import java.util.ArrayDeque
+import kotlin.math.max
+
+class Solution {
+    fun maxValue(nums: IntArray): IntArray {
+        val n = nums.size
+        val st = ArrayDeque<Int>()
+        val uf = UnionFind(n)
+        for (i in 0..<n) {
+            var prev = i
+            if (st.isNotEmpty()) {
+                prev = st.peek()!!
+            }
+            while (!st.isEmpty() && nums[i] < nums[st.peek()!!]) {
+                uf.union(st.pop(), i)
+            }
+            if (nums[i] > nums[prev]) {
+                st.push(i)
+            } else {
+                st.push(prev)
+            }
+        }
+        st.clear()
+        for (i in n - 1 downTo 0) {
+            var prev = i
+            if (!st.isEmpty()) {
+                prev = st.peek()!!
+            }
+            while (!st.isEmpty() && nums[i] > nums[st.peek()!!]) {
+                uf.union(st.pop(), i)
+            }
+            if (nums[i] < nums[prev]) {
+                st.push(i)
+            } else {
+                st.push(prev)
+            }
+        }
+        val map = HashMap<Int?, Int?>()
+        for (i in 0..<n) {
+            val root = uf.find(i)
+            map.put(root, max(map.getOrDefault(root, Int.Companion.MIN_VALUE)!!, nums[i]))
+        }
+        val ans = IntArray(n)
+        for (i in 0..<n) {
+            ans[i] = map.get(uf.find(i))!!
+        }
+        return ans
+    }
+
+    private class UnionFind(n: Int) {
+        var par: IntArray = IntArray(n)
+        var rank: IntArray = IntArray(n)
+
+        init {
+            for (i in 0..<n) {
+                par[i] = i
+            }
+        }
+
+        fun find(x: Int): Int {
+            if (par[x] != x) {
+                par[x] = find(par[x])
+            }
+            return par[x]
+        }
+
+        fun union(x: Int, y: Int) {
+            var x = x
+            var y = y
+            x = find(x)
+            y = find(y)
+            if (x == y) {
+                return
+            }
+            if (rank[x] < rank[y]) {
+                par[x] = y
+            } else if (rank[x] > rank[y]) {
+                par[y] = x
+            } else {
+                par[y] = x
+                rank[x]++
+            }
+        }
+    }
+}

src/main/kotlin/g3601_3700/s3660_jump_game_ix/readme.md

@@ -0,0 +1,47 @@
+3660\. Jump Game IX
+
+Medium
+
+You are given an integer array `nums`.
+
+From any index `i`, you can jump to another index `j` under the following rules:
+
+*   Jump to index `j` where `j > i` is allowed only if `nums[j] < nums[i]`.
+*   Jump to index `j` where `j < i` is allowed only if `nums[j] > nums[i]`.
+
+For each index `i`, find the **maximum** **value** in `nums` that can be reached by following **any** sequence of valid jumps starting at `i`.
+
+Return an array `ans` where `ans[i]` is the **maximum** **value** reachable starting from index `i`.
+
+**Example 1:**
+
+**Input:** nums = [2,1,3]
+
+**Output:** [2,2,3]
+
+**Explanation:**
+
+*   For `i = 0`: No jump increases the value.
+*   For `i = 1`: Jump to `j = 0` as `nums[j] = 2` is greater than `nums[i]`.
+*   For `i = 2`: Since `nums[2] = 3` is the maximum value in `nums`, no jump increases the value.
+
+Thus, `ans = [2, 2, 3]`.
+
+**Example 2:**
+
+**Input:** nums = [2,3,1]
+
+**Output:** [3,3,3]
+
+**Explanation:**
+
+*   For `i = 0`: Jump forward to `j = 2` as `nums[j] = 1` is less than `nums[i] = 2`, then from `i = 2` jump to `j = 1` as `nums[j] = 3` is greater than `nums[2]`.
+*   For `i = 1`: Since `nums[1] = 3` is the maximum value in `nums`, no jump increases the value.
+*   For `i = 2`: Jump to `j = 1` as `nums[j] = 3` is greater than `nums[2] = 1`.
+
+Thus, `ans = [3, 3, 3]`.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>

src/main/kotlin/g3601_3700/s3661_maximum_walls_destroyed_by_robots/Solution.kt

@@ -0,0 +1,122 @@
+package g3601_3700.s3661_maximum_walls_destroyed_by_robots
+
+// #Hard #Weekly_Contest_464 #2025_08_25_Time_233_ms_(100.00%)_Space_75.24_MB_(100.00%)
+
+import kotlin.math.max
+import kotlin.math.min
+
+class Solution {
+    fun maxWalls(robots: IntArray, distance: IntArray, walls: IntArray): Int {
+        val n = robots.size
+        // Pair robots with distances and sort
+        val rpair = Array<IntArray>(n) { IntArray(2) }
+        for (i in 0..<n) {
+            rpair[i][0] = robots[i]
+            rpair[i][1] = distance[i]
+        }
+        rpair.sortWith { a: IntArray, b: IntArray -> a[0].compareTo(b[0]) }
+        val r = IntArray(n)
+        val d = IntArray(n)
+        for (i in 0..<n) {
+            r[i] = rpair[i][0]
+            d[i] = rpair[i][1]
+        }
+        walls.sort()
+        // Count walls at robot positions
+        var base = 0
+        for (i in 0..<n) {
+            val idx = walls.binarySearch(r[i])
+            if (idx >= 0) {
+                base++
+            }
+        }
+        // Tail walls
+        val leftTail = countRange(walls, r[0].toLong() - d[0], r[0] - 1L)
+        val rightTail = countRange(walls, r[n - 1] + 1L, r[n - 1].toLong() + d[n - 1])
+        // Precompute segment ranges
+        val segs = n - 1
+        val max = max(0, segs)
+        val a = IntArray(max)
+        val b = IntArray(max)
+        val c = IntArray(max)
+        for (i in 0..<segs) {
+            val segL = r[i] + 1
+            val segR = r[i + 1] - 1
+            if (segL > segR) {
+                c[i] = 0
+                b[i] = c[i]
+                a[i] = b[i]
+                continue
+            }
+            val aHigh = min(segR, r[i] + d[i])
+            a[i] = countRange(walls, segL.toLong(), aHigh.toLong())
+            val bLow = max(segL, r[i + 1] - d[i + 1])
+            b[i] = countRange(walls, bLow.toLong(), segR.toLong())
+            val cLow = max(segL, r[i + 1] - d[i + 1])
+            val cHigh = min(segR, r[i] + d[i])
+            c[i] = countRange(walls, cLow.toLong(), cHigh.toLong())
+        }
+        val dp = Array<IntArray>(n) { IntArray(2) }
+        dp[0].fill(Int.Companion.MIN_VALUE / 4)
+        // first fires left
+        dp[0][0] = base + leftTail
+        // first fires right
+        dp[0][1] = base
+        for (i in 0..<n - 1) {
+            dp[i + 1].fill(Int.Companion.MIN_VALUE / 4)
+            for (choice in 0..1) {
+                val cur = dp[i][choice]
+                if (cur < 0) {
+                    continue
+                }
+                val addIfNextLeft = if (choice == 1) a[i] + b[i] - c[i] else b[i]
+                dp[i + 1][0] = max(dp[i + 1][0], cur + addIfNextLeft)
+                val addIfNextRight = if (choice == 1) a[i] else 0
+                dp[i + 1][1] = max(dp[i + 1][1], cur + addIfNextRight)
+            }
+        }
+        val res: Int = if (n == 1) {
+            max(dp[0][0], dp[0][1] + rightTail)
+        } else {
+            max(dp[n - 1][0], dp[n - 1][1] + rightTail)
+        }
+        return res
+    }
+
+    private fun countRange(arr: IntArray, l: Long, r: Long): Int {
+        if (l > r || arr.isEmpty()) {
+            return 0
+        }
+        val leftIdx = lowerBound(arr, l)
+        val rightIdx = upperBound(arr, r)
+        return max(0, rightIdx - leftIdx)
+    }
+
+    private fun lowerBound(a: IntArray, x: Long): Int {
+        var l = 0
+        var r = a.size
+        while (l < r) {
+            val m = (l + r) ushr 1
+            if (a[m] < x) {
+                l = m + 1
+            } else {
+                r = m
+            }
+        }
+        return l
+    }
+
+    private fun upperBound(a: IntArray, x: Long): Int {
+        var l = 0
+        var r = a.size
+        while (l < r) {
+            val m = (l + r) ushr 1
+            if (a[m] <= x) {
+                l = m + 1
+            } else {
+                r = m
+            }
+        }
+        return l
+    }
+}