Added tasks 3467-3470

Author: javadev

src/main/kotlin/g3401_3500/s3467_transform_array_by_parity/Solution.kt

@@ -0,0 +1,17 @@
+package g3401_3500.s3467_transform_array_by_parity
+
+// #Easy #2025_03_02_Time_11_ms_(100.00%)_Space_42.68_MB_(100.00%)
+
+class Solution {
+    fun transformArray(nums: IntArray): IntArray {
+        for (i in nums.indices) {
+            if (nums[i] % 2 == 0) {
+                nums[i] = 0
+            } else {
+                nums[i] = 1
+            }
+        }
+        nums.sort()
+        return nums
+    }
+}

src/main/kotlin/g3401_3500/s3467_transform_array_by_parity/readme.md

@@ -0,0 +1,38 @@
+3467\. Transform Array by Parity
+
+Easy
+
+You are given an integer array `nums`. Transform `nums` by performing the following operations in the **exact** order specified:
+
+1.  Replace each even number with 0.
+2.  Replace each odd numbers with 1.
+3.  Sort the modified array in **non-decreasing** order.
+
+Return the resulting array after performing these operations.
+
+**Example 1:**
+
+**Input:** nums = [4,3,2,1]
+
+**Output:** [0,0,1,1]
+
+**Explanation:**
+
+*   Replace the even numbers (4 and 2) with 0 and the odd numbers (3 and 1) with 1. Now, `nums = [0, 1, 0, 1]`.
+*   After sorting `nums` in non-descending order, `nums = [0, 0, 1, 1]`.
+
+**Example 2:**
+
+**Input:** nums = [1,5,1,4,2]
+
+**Output:** [0,0,1,1,1]
+
+**Explanation:**
+
+*   Replace the even numbers (4 and 2) with 0 and the odd numbers (1, 5 and 1) with 1. Now, `nums = [1, 1, 1, 0, 0]`.
+*   After sorting `nums` in non-descending order, `nums = [0, 0, 1, 1, 1]`.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `1 <= nums[i] <= 1000`

src/main/kotlin/g3401_3500/s3468_find_the_number_of_copy_arrays/Solution.kt

@@ -0,0 +1,21 @@
+package g3401_3500.s3468_find_the_number_of_copy_arrays
+
+// #Medium #2025_03_02_Time_4_ms_(100.00%)_Space_112.45_MB_(100.00%)
+
+import kotlin.math.max
+import kotlin.math.min
+
+class Solution {
+    fun countArrays(original: IntArray, bounds: Array<IntArray>): Int {
+        var low = bounds[0][0]
+        var high = bounds[0][1]
+        var ans = high - low + 1
+        for (i in 1..<original.size) {
+            val diff = original[i] - original[i - 1]
+            low = max((low + diff), bounds[i][0])
+            high = min((high + diff), bounds[i][1])
+            ans = min(ans, (high - low + 1)).toInt()
+        }
+        return max(ans, 0)
+    }
+}

src/main/kotlin/g3401_3500/s3468_find_the_number_of_copy_arrays/readme.md

@@ -0,0 +1,58 @@
+3468\. Find the Number of Copy Arrays
+
+Medium
+
+You are given an array `original` of length `n` and a 2D array `bounds` of length `n x 2`, where <code>bounds[i] = [u<sub>i</sub>, v<sub>i</sub>]</code>.
+
+You need to find the number of **possible** arrays `copy` of length `n` such that:
+
+1.  `(copy[i] - copy[i - 1]) == (original[i] - original[i - 1])` for `1 <= i <= n - 1`.
+2.  <code>u<sub>i</sub> <= copy[i] <= v<sub>i</sub></code> for `0 <= i <= n - 1`.
+
+Return the number of such arrays.
+
+**Example 1:**
+
+**Input:** original = [1,2,3,4], bounds = [[1,2],[2,3],[3,4],[4,5]]
+
+**Output:** 2
+
+**Explanation:**
+
+The possible arrays are:
+
+*   `[1, 2, 3, 4]`
+*   `[2, 3, 4, 5]`
+
+**Example 2:**
+
+**Input:** original = [1,2,3,4], bounds = [[1,10],[2,9],[3,8],[4,7]]
+
+**Output:** 4
+
+**Explanation:**
+
+The possible arrays are:
+
+*   `[1, 2, 3, 4]`
+*   `[2, 3, 4, 5]`
+*   `[3, 4, 5, 6]`
+*   `[4, 5, 6, 7]`
+
+**Example 3:**
+
+**Input:** original = [1,2,1,2], bounds = [[1,1],[2,3],[3,3],[2,3]]
+
+**Output:** 0
+
+**Explanation:**
+
+No array is possible.
+
+**Constraints:**
+
+*   <code>2 <= n == original.length <= 10<sup>5</sup></code>
+*   <code>1 <= original[i] <= 10<sup>9</sup></code>
+*   `bounds.length == n`
+*   `bounds[i].length == 2`
+*   <code>1 <= bounds[i][0] <= bounds[i][1] <= 10<sup>9</sup></code>

src/main/kotlin/g3401_3500/s3469_find_minimum_cost_to_remove_array_elements/Solution.kt

@@ -0,0 +1,36 @@
+package g3401_3500.s3469_find_minimum_cost_to_remove_array_elements
+
+// #Medium #2025_03_02_Time_320_ms_(100.00%)_Space_71.87_MB_(100.00%)
+
+import kotlin.math.max
+import kotlin.math.min
+
+class Solution {
+    private lateinit var dp: Array<IntArray>
+
+    fun minCost(nums: IntArray): Int {
+        dp = Array<IntArray>(1001) { IntArray(1001) }
+        dp.forEach { row -> row.fill(-1) }
+        return solve(nums, 1, 0)
+    }
+
+    private fun solve(nums: IntArray, i: Int, last: Int): Int {
+        if (i + 1 >= nums.size) {
+            return max(nums[last], if (i < nums.size) nums[i] else 0)
+        }
+        if (dp[i][last] != -1) {
+            return dp[i][last]
+        }
+        var res: Int = max(nums[i], nums[i + 1]) + solve(nums, i + 2, last)
+        res = min(
+            res,
+            max(nums[i], nums[last]) + solve(nums, i + 2, i + 1)
+        )
+        res = min(
+            res,
+            max(nums[i + 1], nums[last]) + solve(nums, i + 2, i)
+        )
+        dp[i][last] = res
+        return res
+    }
+}

src/main/kotlin/g3401_3500/s3469_find_minimum_cost_to_remove_array_elements/readme.md

@@ -0,0 +1,45 @@
+3469\. Find Minimum Cost to Remove Array Elements
+
+Medium
+
+You are given an integer array `nums`. Your task is to remove **all elements** from the array by performing one of the following operations at each step until `nums` is empty:
+
+*   Choose any two elements from the first three elements of `nums` and remove them. The cost of this operation is the **maximum** of the two elements removed.
+*   If fewer than three elements remain in `nums`, remove all the remaining elements in a single operation. The cost of this operation is the **maximum** of the remaining elements.
+
+Return the **minimum** cost required to remove all the elements.
+
+**Example 1:**
+
+**Input:** nums = [6,2,8,4]
+
+**Output:** 12
+
+**Explanation:**
+
+Initially, `nums = [6, 2, 8, 4]`.
+
+*   In the first operation, remove `nums[0] = 6` and `nums[2] = 8` with a cost of `max(6, 8) = 8`. Now, `nums = [2, 4]`.
+*   In the second operation, remove the remaining elements with a cost of `max(2, 4) = 4`.
+
+The cost to remove all elements is `8 + 4 = 12`. This is the minimum cost to remove all elements in `nums`. Hence, the output is 12.
+
+**Example 2:**
+
+**Input:** nums = [2,1,3,3]
+
+**Output:** 5
+
+**Explanation:**
+
+Initially, `nums = [2, 1, 3, 3]`.
+
+*   In the first operation, remove `nums[0] = 2` and `nums[1] = 1` with a cost of `max(2, 1) = 2`. Now, `nums = [3, 3]`.
+*   In the second operation remove the remaining elements with a cost of `max(3, 3) = 3`.
+
+The cost to remove all elements is `2 + 3 = 5`. This is the minimum cost to remove all elements in `nums`. Hence, the output is 5.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   <code>1 <= nums[i] <= 10<sup>6</sup></code>

src/main/kotlin/g3401_3500/s3470_permutations_iv/Solution.kt

@@ -0,0 +1,114 @@
+package g3401_3500.s3470_permutations_iv
+
+// #Hard #2025_03_02_Time_63_ms_(100.00%)_Space_38.70_MB_(100.00%)
+
+class Solution {
+    private fun helper(a: Int, b: Int): Long {
+        var res: Long = 1
+        for (i in 0..<b) {
+            res *= (a - i).toLong()
+            if (res > INF) {
+                return INF
+            }
+        }
+        return res
+    }
+
+    private fun solve(odd: Int, even: Int, r: Int, req: Int): Long {
+        if (r == 0) {
+            return 1
+        }
+        val nOdd: Int
+        val nEven: Int
+        if (req == 1) {
+            nOdd = (r + 1) / 2
+            nEven = r / 2
+        } else {
+            nEven = (r + 1) / 2
+            nOdd = r / 2
+        }
+        if (odd < nOdd || even < nEven) {
+            return 0
+        }
+        val oddWays = helper(odd, nOdd)
+        val evenWays = helper(even, nEven)
+        var total = oddWays
+        if (evenWays == 0L || total > INF / evenWays) {
+            total = INF
+        } else {
+            total *= evenWays
+        }
+        return total
+    }
+
+    fun permute(n: Int, k: Long): IntArray {
+        var k = k
+        val ans: MutableList<Int> = ArrayList<Int>()
+        var first = false
+        val used = BooleanArray(n + 1)
+        var odd = (n + 1) / 2
+        var even = n / 2
+        var last = -1
+        for (i in 1..n) {
+            if (!used[i]) {
+                var odd2 = odd
+                var even2 = even
+                val cp = i and 1
+                val next = (if (cp == 1) 0 else 1)
+                if (cp == 1) {
+                    odd2--
+                } else {
+                    even2--
+                }
+                val r = n - 1
+                val cnt = solve(odd2, even2, r, next)
+                if (k > cnt) {
+                    k -= cnt
+                } else {
+                    ans.add(i)
+                    used[i] = true
+                    odd = odd2
+                    even = even2
+                    last = cp
+                    first = true
+                    break
+                }
+            }
+        }
+        if (!first) {
+            return IntArray(0)
+        }
+        for (z in 1..<n) {
+            for (j in 1..n) {
+                if (!used[j] && ((j and 1) != last)) {
+                    var odd2 = odd
+                    var even2 = even
+                    val cp = j and 1
+                    if (cp == 1) {
+                        odd2--
+                    } else {
+                        even2--
+                    }
+                    val r = n - (z + 1)
+                    val next = (if (cp == 1) 0 else 1)
+                    val cnt2 = solve(odd2, even2, r, next)
+                    if (k > cnt2) {
+                        k -= cnt2
+                    } else {
+                        ans.add(j)
+                        used[j] = true
+                        odd = odd2
+                        even = even2
+                        last = cp
+                        break
+                    }
+                }
+            }
+        }
+        return ans.stream().mapToInt { i: Int? -> i!! }.toArray()
+    }
+
+    companion object {
+        private const val INF = 1000000000000000000L
+    }
+}