Added tasks 3398, 3399

Author: javadev

src/main/java/g3301_3400/s3398_smallest_substring_with_identical_characters_i/Solution.java

@@ -0,0 +1,67 @@
+package g3301_3400.s3398_smallest_substring_with_identical_characters_i;
+
+// #Hard #2024_12_24_Time_1_ms_(100.00%)_Space_42.9_MB_(39.83%)
+
+public class Solution {
+    public int minLength(String s, int ops) {
+        char[] arr2 = s.toCharArray();
+        int q = '0';
+        int w = '1';
+        int p1 = ops;
+        int p2 = ops;
+        for (int i = 0; i < s.length(); i++) {
+            if (arr2[i] != q) {
+                p1--;
+            }
+            if (arr2[i] != w) {
+                p2--;
+            }
+            if (q == '0') {
+                q = '1';
+            } else {
+                q = '0';
+            }
+            if (w == '0') {
+                w = '1';
+            } else {
+                w = '0';
+            }
+        }
+        if (p1 >= 0 || p2 >= 0) {
+            return 1;
+        }
+        int low = 2;
+        int high = s.length();
+        int ans = 0;
+        int n = s.length();
+        while (low <= high) {
+            int mid = (low + high) / 2;
+            char[] arr = s.toCharArray();
+            int p = ops;
+            int c = 1;
+            for (int i = 1; i < n; i++) {
+                if (arr[i] == arr[i - 1]) {
+                    c++;
+                } else {
+                    c = 1;
+                }
+                if (c > mid) {
+                    if (arr[i - 1] == '0') {
+                        arr[i - 1] = '1';
+                    } else {
+                        arr[i - 1] = '0';
+                    }
+                    p--;
+                    c = 0;
+                }
+            }
+            if (p < 0) {
+                low = mid + 1;
+            } else {
+                ans = mid;
+                high = mid - 1;
+            }
+        }
+        return ans;
+    }
+}

src/main/java/g3301_3400/s3398_smallest_substring_with_identical_characters_i/readme.md

@@ -0,0 +1,45 @@
+3398\. Smallest Substring With Identical Characters I
+
+Hard
+
+You are given a binary string `s` of length `n` and an integer `numOps`.
+
+You are allowed to perform the following operation on `s` **at most** `numOps` times:
+
+*   Select any index `i` (where `0 <= i < n`) and **flip** `s[i]`. If `s[i] == '1'`, change `s[i]` to `'0'` and vice versa.
+
+You need to **minimize** the length of the **longest** substring of `s` such that all the characters in the substring are **identical**.
+
+Return the **minimum** length after the operations.
+
+**Example 1:**
+
+**Input:** s = "000001", numOps = 1
+
+**Output:** 2
+
+**Explanation:**
+
+By changing `s[2]` to `'1'`, `s` becomes `"001001"`. The longest substrings with identical characters are `s[0..1]` and `s[3..4]`.
+
+**Example 2:**
+
+**Input:** s = "0000", numOps = 2
+
+**Output:** 1
+
+**Explanation:**
+
+By changing `s[0]` and `s[2]` to `'1'`, `s` becomes `"1010"`.
+
+**Example 3:**
+
+**Input:** s = "0101", numOps = 0
+
+**Output:** 1
+
+**Constraints:**
+
+*   `1 <= n == s.length <= 1000`
+*   `s` consists only of `'0'` and `'1'`.
+*   `0 <= numOps <= n`

src/main/java/g3301_3400/s3399_smallest_substring_with_identical_characters_ii/Solution.java

@@ -0,0 +1,87 @@
+package g3301_3400.s3399_smallest_substring_with_identical_characters_ii;
+
+// #Hard #2024_12_24_Time_11_ms_(100.00%)_Space_45.7_MB_(54.55%)
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    public int minLength(String s, int numOps) {
+        int l = s.length();
+        int lingyi = 0;
+        int yiling = 0;
+        List<Integer> pq = new ArrayList<>();
+        char thisone = s.charAt(0);
+        int chang = 1;
+        if (thisone == '0') {
+            yiling++;
+        } else {
+            lingyi++;
+        }
+        for (int i = 1; i < l; i++) {
+            char cur = s.charAt(i);
+            if (cur == thisone) {
+                chang++;
+            } else {
+                if (chang >= 2) {
+                    pq.add(chang);
+                }
+                chang = 1;
+                thisone = cur;
+            }
+            if (i % 2 == 0) {
+                if (cur == '0') {
+                    yiling++;
+                } else {
+                    lingyi++;
+                }
+            } else {
+                if (cur == '0') {
+                    lingyi++;
+                } else {
+                    yiling++;
+                }
+            }
+        }
+        if (numOps >= lingyi || numOps >= yiling) {
+            return 1;
+        }
+        if (chang >= 2) {
+            pq.add(chang);
+        }
+        int one = -1;
+        int two = -1;
+        for (int cur : pq) {
+            if (cur > one) {
+                two = one;
+                one = cur;
+            } else if (cur > two) {
+                two = cur;
+            }
+        }
+        if (two == -1) {
+            return one / (numOps + 1) > 1 ? one / (numOps + 1) : 2;
+        }
+        if (numOps == 0) {
+            return one;
+        }
+        if (numOps == 1) {
+            return (one / 2 > two) ? (one / 2 == 1 ? 2 : one / 2) : two;
+        }
+        int left = 2;
+        int right = l / (numOps + 1);
+        while (left < right) {
+            int mid = left + (right - left) / 2;
+            int sum = 0;
+            for (Integer integer : pq) {
+                sum += integer / (mid + 1);
+            }
+            if (sum <= numOps) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    }
+}

src/main/java/g3301_3400/s3399_smallest_substring_with_identical_characters_ii/readme.md

@@ -0,0 +1,45 @@
+3399\. Smallest Substring With Identical Characters II
+
+Hard
+
+You are given a binary string `s` of length `n` and an integer `numOps`.
+
+You are allowed to perform the following operation on `s` **at most** `numOps` times:
+
+*   Select any index `i` (where `0 <= i < n`) and **flip** `s[i]`. If `s[i] == '1'`, change `s[i]` to `'0'` and vice versa.
+
+You need to **minimize** the length of the **longest** substring of `s` such that all the characters in the substring are **identical**.
+
+Return the **minimum** length after the operations.
+
+**Example 1:**
+
+**Input:** s = "000001", numOps = 1
+
+**Output:** 2
+
+**Explanation:**
+
+By changing `s[2]` to `'1'`, `s` becomes `"001001"`. The longest substrings with identical characters are `s[0..1]` and `s[3..4]`.
+
+**Example 2:**
+
+**Input:** s = "0000", numOps = 2
+
+**Output:** 1
+
+**Explanation:**
+
+By changing `s[0]` and `s[2]` to `'1'`, `s` becomes `"1010"`.
+
+**Example 3:**
+
+**Input:** s = "0101", numOps = 0
+
+**Output:** 1
+
+**Constraints:**
+
+*   <code>1 <= n == s.length <= 10<sup>5</sup></code>
+*   `s` consists only of `'0'` and `'1'`.
+*   `0 <= numOps <= n`

src/test/java/g3301_3400/s3398_smallest_substring_with_identical_characters_i/SolutionTest.java

@@ -0,0 +1,23 @@
+package g3301_3400.s3398_smallest_substring_with_identical_characters_i;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void minLength() {
+        assertThat(new Solution().minLength("000001", 1), equalTo(1));
+    }
+
+    @Test
+    void minLength2() {
+        assertThat(new Solution().minLength("0000", 2), equalTo(1));
+    }
+
+    @Test
+    void minLength3() {
+        assertThat(new Solution().minLength("0101", 0), equalTo(1));
+    }
+}

src/test/java/g3301_3400/s3399_smallest_substring_with_identical_characters_ii/SolutionTest.java

@@ -0,0 +1,23 @@
+package g3301_3400.s3399_smallest_substring_with_identical_characters_ii;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void minLength() {
+        assertThat(new Solution().minLength("000001", 1), equalTo(2));
+    }
+
+    @Test
+    void minLength2() {
+        assertThat(new Solution().minLength("0000", 2), equalTo(1));
+    }
+
+    @Test
+    void minLength3() {
+        assertThat(new Solution().minLength("0101", 0), equalTo(1));
+    }
+}