Added tasks 2769-2773

Author: javadev

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

@@ -0,0 +1,9 @@
+package g2701_2800.s2769_find_the_maximum_achievable_number
+
+// #Easy #Math #2023_08_11_Time_134_ms_(97.89%)_Space_33.8_MB_(81.05%)
+
+class Solution {
+    fun theMaximumAchievableX(num: Int, t: Int): Int {
+        return num + t * 2
+    }
+}

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

@@ -0,0 +1,45 @@
+2769\. Find the Maximum Achievable Number
+
+Easy
+
+You are given two integers, `num` and `t`.
+
+An integer `x` is called **achievable** if it can become equal to `num` after applying the following operation no more than `t` times:
+
+*   Increase or decrease `x` by `1`, and simultaneously increase or decrease `num` by `1`.
+
+Return _the maximum possible achievable number_. It can be proven that there exists at least one achievable number.
+
+**Example 1:**
+
+**Input:** num = 4, t = 1
+
+**Output:** 6
+
+**Explanation:**
+
+The maximum achievable number is x = 6; it can become equal to num after performing this operation:
+
+1- Decrease x by 1, and increase num by 1. Now, x = 5 and num = 5.
+
+It can be proven that there is no achievable number larger than 6. 
+
+**Example 2:**
+
+**Input:** num = 3, t = 2
+
+**Output:** 7
+
+**Explanation:**
+
+The maximum achievable number is x = 7; after performing these operations, x will equal num:
+
+1- Decrease x by 1, and increase num by 1. Now, x = 6 and num = 4.
+
+2- Decrease x by 1, and increase num by 1. Now, x = 5 and num = 5.
+
+It can be proven that there is no achievable number larger than 7. 
+
+**Constraints:**
+
+*   `1 <= num, t <= 50`

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

@@ -0,0 +1,24 @@
+package g2701_2800.s2770_maximum_number_of_jumps_to_reach_the_last_index
+
+// #Medium #Array #Dynamic_Programming #2023_08_11_Time_325_ms_(51.16%)_Space_49.1_MB_(13.95%)
+
+class Solution {
+    private class Pair(var prev: Int, var len: Int)
+
+    fun maximumJumps(nums: IntArray, target: Int): Int {
+        val arr = arrayOfNulls<Pair>(nums.size)
+        arr[0] = Pair(0, 0)
+        for (i in 1 until nums.size) {
+            arr[i] = Pair(-1, 0)
+            for (j in i - 1 downTo 0) {
+                if (Math.abs(nums[i] - nums[j]) <= target &&
+                    arr[j]!!.prev != -1 && arr[j]!!.len + 1 > arr[i]!!.len
+                ) {
+                    arr[i]!!.prev = j
+                    arr[i]!!.len = arr[j]!!.len + 1
+                }
+            }
+        }
+        return if (arr[nums.size - 1]!!.len > 0) arr[nums.size - 1]!!.len else -1
+    }
+}

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

@@ -0,0 +1,72 @@
+2770\. Maximum Number of Jumps to Reach the Last Index
+
+Medium
+
+You are given a **0-indexed** array `nums` of `n` integers and an integer `target`.
+
+You are initially positioned at index `0`. In one step, you can jump from index `i` to any index `j` such that:
+
+*   `0 <= i < j < n`
+*   `-target <= nums[j] - nums[i] <= target`
+
+Return _the **maximum number of jumps** you can make to reach index_ `n - 1`.
+
+If there is no way to reach index `n - 1`, return `-1`.
+
+**Example 1:**
+
+**Input:** nums = [1,3,6,4,1,2], target = 2
+
+**Output:** 3
+
+**Explanation:**
+
+To go from index 0 to index n - 1 with the maximum number of jumps, you can perform the following jumping sequence:
+
+- Jump from index 0 to index 1.
+
+- Jump from index 1 to index 3.
+
+- Jump from index 3 to index 5.
+
+It can be proven that there is no other jumping sequence that goes from 0 to n - 1 with more than 3 jumps.
+
+Hence, the answer is 3. 
+
+**Example 2:**
+
+**Input:** nums = [1,3,6,4,1,2], target = 3
+
+**Output:** 5
+
+**Explanation:**
+
+To go from index 0 to index n - 1 with the maximum number of jumps, you can perform the following jumping sequence:
+
+- Jump from index 0 to index 1.
+
+- Jump from index 1 to index 2.
+
+- Jump from index 2 to index 3.
+
+- Jump from index 3 to index 4.
+
+- Jump from index 4 to index 5.
+
+It can be proven that there is no other jumping sequence that goes from 0 to n - 1 with more than 5 jumps.
+
+Hence, the answer is 5. 
+
+**Example 3:**
+
+**Input:** nums = [1,3,6,4,1,2], target = 0
+
+**Output:** -1
+
+**Explanation:** It can be proven that there is no jumping sequence that goes from 0 to n - 1. Hence, the answer is -1. 
+
+**Constraints:**
+
+*   `2 <= nums.length == n <= 1000`
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>
+*   <code>0 <= target <= 2 * 10<sup>9</sup></code>

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

@@ -0,0 +1,26 @@
+package g2701_2800.s2771_longest_non_decreasing_subarray_from_two_arrays
+
+// #Medium #Array #Dynamic_Programming #2023_08_11_Time_665_ms_(96.88%)_Space_77.8_MB_(53.13%)
+
+class Solution {
+    fun maxNonDecreasingLength(nums1: IntArray, nums2: IntArray): Int {
+        var res = 1
+        var dp1 = 1
+        var dp2 = 1
+        val n = nums1.size
+        var t11: Int
+        var t12: Int
+        var t21: Int
+        var t22: Int
+        for (i in 1 until n) {
+            t11 = if (nums1[i - 1] <= nums1[i]) dp1 + 1 else 1
+            t12 = if (nums1[i - 1] <= nums2[i]) dp1 + 1 else 1
+            t21 = if (nums2[i - 1] <= nums1[i]) dp2 + 1 else 1
+            t22 = if (nums2[i - 1] <= nums2[i]) dp2 + 1 else 1
+            dp1 = Math.max(t11, t21)
+            dp2 = Math.max(t12, t22)
+            res = Math.max(res, Math.max(dp1, dp2))
+        }
+        return res
+    }
+}

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

@@ -0,0 +1,62 @@
+2771\. Longest Non-decreasing Subarray From Two Arrays
+
+Medium
+
+You are given two **0-indexed** integer arrays `nums1` and `nums2` of length `n`.
+
+Let's define another **0-indexed** integer array, `nums3`, of length `n`. For each index `i` in the range `[0, n - 1]`, you can assign either `nums1[i]` or `nums2[i]` to `nums3[i]`.
+
+Your task is to maximize the length of the **longest non-decreasing subarray** in `nums3` by choosing its values optimally.
+
+Return _an integer representing the length of the **longest non-decreasing** subarray in_ `nums3`.
+
+**Note:** A **subarray** is a contiguous **non-empty** sequence of elements within an array.
+
+**Example 1:**
+
+**Input:** nums1 = [2,3,1], nums2 = [1,2,1]
+
+**Output:** 2
+
+**Explanation:**
+
+One way to construct nums3 is:
+
+nums3 = [nums1[0], nums2[1], nums2[2]] => [2,2,1].
+
+The subarray starting from index 0 and ending at index 1, [2,2], forms a non-decreasing subarray of length 2.
+
+We can show that 2 is the maximum achievable length.
+
+**Example 2:**
+
+**Input:** nums1 = [1,3,2,1], nums2 = [2,2,3,4]
+
+**Output:** 4
+
+**Explanation:**
+
+One way to construct nums3 is:
+
+nums3 = [nums1[0], nums2[1], nums2[2], nums2[3]] => [1,2,3,4].
+
+The entire array forms a non-decreasing subarray of length 4, making it the maximum achievable length. 
+
+**Example 3:**
+
+**Input:** nums1 = [1,1], nums2 = [2,2]
+
+**Output:** 2
+
+**Explanation:**
+
+One way to construct nums3 is:
+
+nums3 = [nums1[0], nums1[1]] => [1,1].
+
+The entire array forms a non-decreasing subarray of length 2, making it the maximum achievable length. 
+
+**Constraints:**
+
+*   <code>1 <= nums1.length == nums2.length == n <= 10<sup>5</sup></code>
+*   <code>1 <= nums1[i], nums2[i] <= 10<sup>9</sup></code>

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

@@ -0,0 +1,21 @@
+package g2701_2800.s2772_apply_operations_to_make_all_array_elements_equal_to_zero
+
+// #Medium #Array #Prefix_Sum #2023_08_11_Time_578_ms_(97.06%)_Space_71.5_MB_(20.59%)
+
+class Solution {
+    fun checkArray(nums: IntArray, k: Int): Boolean {
+        var cur = 0
+        val n = nums.size
+        for (i in 0 until n) {
+            if (cur > nums[i]) {
+                return false
+            }
+            nums[i] -= cur
+            cur += nums[i]
+            if (i >= k - 1) {
+                cur -= nums[i - k + 1]
+            }
+        }
+        return cur == 0
+    }
+}

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

@@ -0,0 +1,42 @@
+2772\. Apply Operations to Make All Array Elements Equal to Zero
+
+Medium
+
+You are given a **0-indexed** integer array `nums` and a positive integer `k`.
+
+You can apply the following operation on the array **any** number of times:
+
+*   Choose **any** subarray of size `k` from the array and **decrease** all its elements by `1`.
+
+Return `true` _if you can make all the array elements equal to_ `0`_, or_ `false` _otherwise_.
+
+A **subarray** is a contiguous non-empty part of an array.
+
+**Example 1:**
+
+**Input:** nums = [2,2,3,1,1,0], k = 3
+
+**Output:** true
+
+**Explanation:**
+
+We can do the following operations:
+
+- Choose the subarray [2,2,3]. The resulting array will be nums = [**<ins>1</ins>**,**<ins>1</ins>**,**<ins>2</ins>**,1,1,0].
+
+- Choose the subarray [2,1,1]. The resulting array will be nums = [1,1,**<ins>1</ins>**,**<ins>0</ins>**,**<ins>0</ins>**,0].
+
+- Choose the subarray [1,1,1]. The resulting array will be nums = [<ins>**0**</ins>,<ins>**0**</ins>,<ins>**0**</ins>,0,0,0]. 
+
+**Example 2:**
+
+**Input:** nums = [1,3,1,1], k = 2
+
+**Output:** false
+
+**Explanation:** It is not possible to make all the array elements equal to 0. 
+
+**Constraints:**
+
+*   <code>1 <= k <= nums.length <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>6</sup></code>

src/test/kotlin/g2701_2800/s2769_find_the_maximum_achievable_number/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g2701_2800.s2769_find_the_maximum_achievable_number
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun theMaximumAchievableX() {
+        assertThat(Solution().theMaximumAchievableX(4, 1), equalTo(6))
+    }
+
+    @Test
+    fun theMaximumAchievableX2() {
+        assertThat(Solution().theMaximumAchievableX(3, 2), equalTo(7))
+    }
+}

src/test/kotlin/g2701_2800/s2770_maximum_number_of_jumps_to_reach_the_last_index/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g2701_2800.s2770_maximum_number_of_jumps_to_reach_the_last_index
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun maximumJumps() {
+        assertThat(Solution().maximumJumps(intArrayOf(1, 3, 6, 4, 1, 2), 2), equalTo(3))
+    }
+
+    @Test
+    fun maximumJumps2() {
+        assertThat(Solution().maximumJumps(intArrayOf(1, 3, 6, 4, 1, 2), 3), equalTo(5))
+    }
+
+    @Test
+    fun maximumJumps3() {
+        assertThat(Solution().maximumJumps(intArrayOf(1, 3, 6, 4, 1, 2), 0), equalTo(-1))
+    }
+}