Added tasks 2024, 2025, 2027.

Author: ThanhNIT

src/main/java/g2001_2100/s2024_maximize_the_confusion_of_an_exam/Solution.java

@@ -0,0 +1,55 @@
+package g2001_2100.s2024_maximize_the_confusion_of_an_exam;
+
+// #Medium #String #Binary_Search #Prefix_Sum #Sliding_Window
+// #2022_05_25_Time_21_ms_(44.78%)_Space_48.4_MB_(29.41%)
+
+public class Solution {
+    public int maxConsecutiveAnswers(String answerKey, int k) {
+        int max;
+        int right = 0;
+        int originalK = k;
+        while (k > 0 && right < answerKey.length()) {
+            if (answerKey.charAt(right) == 'T') {
+                k--;
+            }
+            right++;
+        }
+        max = right;
+        int left = 0;
+        while (right < answerKey.length() && left < answerKey.length()) {
+            if (answerKey.charAt(right) == 'F') {
+                right++;
+                max = Math.max(max, right - left);
+            } else {
+                while (left < right && answerKey.charAt(left) == 'F') {
+                    left++;
+                }
+                left++;
+                right++;
+            }
+        }
+        right = 0;
+        k = originalK;
+        while (k > 0 && right < answerKey.length()) {
+            if (answerKey.charAt(right) == 'F') {
+                k--;
+            }
+            right++;
+        }
+        max = Math.max(max, right);
+        left = 0;
+        while (right < answerKey.length() && left < answerKey.length()) {
+            if (answerKey.charAt(right) == 'T') {
+                right++;
+                max = Math.max(max, right - left);
+            } else {
+                while (left < right && answerKey.charAt(left) == 'T') {
+                    left++;
+                }
+                left++;
+                right++;
+            }
+        }
+        return max;
+    }
+}

src/main/java/g2001_2100/s2024_maximize_the_confusion_of_an_exam/readme.md

@@ -0,0 +1,52 @@
+2024\. Maximize the Confusion of an Exam
+
+Medium
+
+A teacher is writing a test with `n` true/false questions, with `'T'` denoting true and `'F'` denoting false. He wants to confuse the students by **maximizing** the number of **consecutive** questions with the **same** answer (multiple trues or multiple falses in a row).
+
+You are given a string `answerKey`, where `answerKey[i]` is the original answer to the <code>i<sup>th</sup></code> question. In addition, you are given an integer `k`, the maximum number of times you may perform the following operation:
+
+*   Change the answer key for any question to `'T'` or `'F'` (i.e., set `answerKey[i]` to `'T'` or `'F'`).
+
+Return _the **maximum** number of consecutive_ `'T'`s or `'F'`s _in the answer key after performing the operation at most_ `k` _times_.
+
+**Example 1:**
+
+**Input:** answerKey = "TTFF", k = 2
+
+**Output:** 4
+
+**Explanation:** We can replace both the 'F's with 'T's to make answerKey = "TTTT". 
+
+There are four consecutive 'T's.
+
+**Example 2:**
+
+**Input:** answerKey = "TFFT", k = 1
+
+**Output:** 3
+
+**Explanation:** We can replace the first 'T' with an 'F' to make answerKey = "FFFT". 
+
+Alternatively, we can replace the second 'T' with an 'F' to make answerKey = "TFFF". 
+
+In both cases, there are three consecutive 'F's.
+
+**Example 3:**
+
+**Input:** answerKey = "TTFTTFTT", k = 1
+
+**Output:** 5
+
+**Explanation:** We can replace the first 'F' to make answerKey = "TTTTTFTT" 
+
+Alternatively, we can replace the second 'F' to make answerKey = "TTFTTTTT". 
+
+In both cases, there are five consecutive 'T's.
+
+**Constraints:**
+
+*   `n == answerKey.length`
+*   <code>1 <= n <= 5 * 10<sup>4</sup></code>
+*   `answerKey[i]` is either `'T'` or `'F'`
+*   `1 <= k <= n`

src/main/java/g2001_2100/s2025_maximum_number_of_ways_to_partition_an_array/Solution.java

@@ -0,0 +1,69 @@
+package g2001_2100.s2025_maximum_number_of_ways_to_partition_an_array;
+
+// #Hard #Array #Hash_Table #Prefix_Sum #Counting #Enumeration
+// #2022_05_25_Time_172_ms_(100.00%)_Space_75.5_MB_(65.10%)
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution {
+    public int waysToPartition(int[] nums, int k) {
+        int n = nums.length;
+        long[] ps = new long[n];
+        ps[0] = nums[0];
+        for (int i = 1; i < n; i++) {
+            ps[i] = ps[i - 1] + nums[i];
+        }
+        Map<Long, ArrayList<Integer>> partDiffs = new HashMap<>();
+        int maxWays = 0;
+        for (int i = 1; i < n; i++) {
+            long partL = ps[i - 1];
+            long partR = ps[n - 1] - partL;
+            long partDiff = partR - partL;
+            if (partDiff == 0) {
+                maxWays++;
+            }
+            ArrayList<Integer> idxSet =
+                    partDiffs.computeIfAbsent(partDiff, k1 -> new ArrayList<>());
+            idxSet.add(i);
+        }
+        for (int j = 0; j < n; j++) {
+            int ways = 0;
+            long newDiff = (long) k - nums[j];
+            ArrayList<Integer> leftList = partDiffs.get(newDiff);
+            if (leftList != null) {
+                int i = upperBound(leftList, j);
+                ways += leftList.size() - i;
+            }
+            ArrayList<Integer> rightList = partDiffs.get(-newDiff);
+            if (rightList != null) {
+                int i = upperBound(rightList, j);
+                ways += i;
+            }
+            maxWays = Math.max(ways, maxWays);
+        }
+        return maxWays;
+    }
+
+    public static int upperBound(List<Integer> arr, int val) {
+        int ans = -1;
+        int n = arr.size();
+        int l = 0;
+        int r = n;
+        while (l <= r) {
+            int mid = l + (r - l) / 2;
+            if (mid == n) {
+                return n;
+            }
+            if (arr.get(mid) > val) {
+                ans = mid;
+                r = mid - 1;
+            } else {
+                l = mid + 1;
+            }
+        }
+        return ans;
+    }
+}

src/main/java/g2001_2100/s2025_maximum_number_of_ways_to_partition_an_array/readme.md

@@ -0,0 +1,54 @@
+2025\. Maximum Number of Ways to Partition an Array
+
+Hard
+
+You are given a **0-indexed** integer array `nums` of length `n`. The number of ways to **partition** `nums` is the number of `pivot` indices that satisfy both conditions:
+
+*   `1 <= pivot < n`
+*   `nums[0] + nums[1] + ... + nums[pivot - 1] == nums[pivot] + nums[pivot + 1] + ... + nums[n - 1]`
+
+You are also given an integer `k`. You can choose to change the value of **one** element of `nums` to `k`, or to leave the array **unchanged**.
+
+Return _the **maximum** possible number of ways to **partition**_ `nums` _to satisfy both conditions after changing **at most** one element_.
+
+**Example 1:**
+
+**Input:** nums = [2,-1,2], k = 3
+
+**Output:** 1
+
+**Explanation:** One optimal approach is to change nums[0] to k. The array becomes [**3**,-1,2]. 
+
+There is one way to partition the array: 
+
+- For pivot = 2, we have the partition [3,-1 | 2]: 3 + -1 == 2.
+
+**Example 2:**
+
+**Input:** nums = [0,0,0], k = 1
+
+**Output:** 2
+
+**Explanation:** The optimal approach is to leave the array unchanged. 
+
+There are two ways to partition the array: 
+
+- For pivot = 1, we have the partition [0 | 0,0]: 0 == 0 + 0. 
+
+- For pivot = 2, we have the partition [0,0 | 0]: 0 + 0 == 0.
+
+**Example 3:**
+
+**Input:** nums = [22,4,-25,-20,-15,15,-16,7,19,-10,0,-13,-14], k = -33
+
+**Output:** 4
+
+**Explanation:** One optimal approach is to change nums[2] to k. The array becomes [22,4,**\-33**,-20,-15,15,-16,7,19,-10,0,-13,-14]. 
+
+There are four ways to partition the array.
+
+**Constraints:**
+
+*   `n == nums.length`
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   <code>-10<sup>5</sup> <= k, nums[i] <= 10<sup>5</sup></code>

src/main/java/g2001_2100/s2027_minimum_moves_to_convert_string/Solution.java

@@ -0,0 +1,24 @@
+package g2001_2100.s2027_minimum_moves_to_convert_string;
+
+// #Easy #String #Greedy #2022_05_25_Time_4_ms_(5.74%)_Space_42.1_MB_(37.50%)
+
+public class Solution {
+    public int minimumMoves(String s) {
+        int moves = 0;
+        int i = 0;
+        while (i < s.length()) {
+            if (s.charAt(i) == 'O') {
+                i++;
+                continue;
+            }
+            String candidate = i + 3 <= s.length() ? s.substring(i, i + 3) : s.substring(i);
+            if (candidate.contains("X")) {
+                moves++;
+                i += 3;
+            } else {
+                i++;
+            }
+        }
+        return moves;
+    }
+}

src/main/java/g2001_2100/s2027_minimum_moves_to_convert_string/readme.md

@@ -0,0 +1,42 @@
+2027\. Minimum Moves to Convert String
+
+Easy
+
+You are given a string `s` consisting of `n` characters which are either `'X'` or `'O'`.
+
+A **move** is defined as selecting **three** **consecutive characters** of `s` and converting them to `'O'`. Note that if a move is applied to the character `'O'`, it will stay the **same**.
+
+Return _the **minimum** number of moves required so that all the characters of_ `s` _are converted to_ `'O'`.
+
+**Example 1:**
+
+**Input:** s = "XXX"
+
+**Output:** 1
+
+**Explanation:** XXX -> OOO We select all the 3 characters and convert them in one move.
+
+**Example 2:**
+
+**Input:** s = "XXOX"
+
+**Output:** 2
+
+**Explanation:** XXOX -> OOOX -> OOOO 
+
+We select the first 3 characters in the first move, and convert them to `'O'`. 
+
+Then we select the last 3 characters and convert them so that the final string contains all `'O'`s.
+
+**Example 3:**
+
+**Input:** s = "OOOO"
+
+**Output:** 0
+
+**Explanation:** There are no `'X's` in `s` to convert.
+
+**Constraints:**
+
+*   `3 <= s.length <= 1000`
+*   `s[i]` is either `'X'` or `'O'`.

src/test/java/g2001_2100/s2024_maximize_the_confusion_of_an_exam/SolutionTest.java

@@ -0,0 +1,23 @@
+package g2001_2100.s2024_maximize_the_confusion_of_an_exam;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void maxConsecutiveAnswers() {
+        assertThat(new Solution().maxConsecutiveAnswers("TTFF", 2), equalTo(4));
+    }
+
+    @Test
+    void maxConsecutiveAnswers2() {
+        assertThat(new Solution().maxConsecutiveAnswers("TTFF", 1), equalTo(3));
+    }
+
+    @Test
+    void maxConsecutiveAnswers3() {
+        assertThat(new Solution().maxConsecutiveAnswers("TTFTTFTT", 1), equalTo(5));
+    }
+}

src/test/java/g2001_2100/s2025_maximum_number_of_ways_to_partition_an_array/SolutionTest.java

@@ -0,0 +1,28 @@
+package g2001_2100.s2025_maximum_number_of_ways_to_partition_an_array;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void waysToPartition() {
+        assertThat(new Solution().waysToPartition(new int[] {2, -1, 2}, 3), equalTo(1));
+    }
+
+    @Test
+    void waysToPartition2() {
+        assertThat(new Solution().waysToPartition(new int[] {0, 0, 0}, 1), equalTo(2));
+    }
+
+    @Test
+    void waysToPartition3() {
+        assertThat(
+                new Solution()
+                        .waysToPartition(
+                                new int[] {22, 4, -25, -20, -15, 15, -16, 7, 19, -10, 0, -13, -14},
+                                -33),
+                equalTo(4));
+    }
+}

src/test/java/g2001_2100/s2027_minimum_moves_to_convert_string/SolutionTest.java

@@ -0,0 +1,23 @@
+package g2001_2100.s2027_minimum_moves_to_convert_string;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void minimumMoves() {
+        assertThat(new Solution().minimumMoves("XXX"), equalTo(1));
+    }
+
+    @Test
+    void minimumMoves2() {
+        assertThat(new Solution().minimumMoves("XXOX"), equalTo(2));
+    }
+
+    @Test
+    void minimumMoves3() {
+        assertThat(new Solution().minimumMoves("OOOO"), equalTo(0));
+    }
+}