Added tasks 3398, 3399

Author: javadev

src/main/kotlin/g3301_3400/s3398_smallest_substring_with_identical_characters_i/Solution.kt

@@ -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%)
+
+class Solution {
+    fun minLength(s: String, ops: Int): Int {
+        val arr2 = s.toCharArray()
+        var q = '0'.code
+        var w = '1'.code
+        var p1 = ops
+        var p2 = ops
+        for (i in 0..<s.length) {
+            if (arr2[i].code != q) {
+                p1--
+            }
+            if (arr2[i].code != w) {
+                p2--
+            }
+            if (q == '0'.code) {
+                q = '1'.code
+            } else {
+                q = '0'.code
+            }
+            if (w == '0'.code) {
+                w = '1'.code
+            } else {
+                w = '0'.code
+            }
+        }
+        if (p1 >= 0 || p2 >= 0) {
+            return 1
+        }
+        var low = 2
+        var high = s.length
+        var ans = 0
+        val n = s.length
+        while (low <= high) {
+            val mid = (low + high) / 2
+            val arr = s.toCharArray()
+            var p = ops
+            var c = 1
+            for (i in 1..<n) {
+                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/kotlin/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/kotlin/g3301_3400/s3399_smallest_substring_with_identical_characters_ii/Solution.kt

@@ -0,0 +1,84 @@
+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%)
+
+class Solution {
+    fun minLength(s: String, numOps: Int): Int {
+        val l = s.length
+        var lingyi = 0
+        var yiling = 0
+        val pq: MutableList<Int> = ArrayList<Int>()
+        var thisone = s.get(0)
+        var chang = 1
+        if (thisone == '0') {
+            yiling++
+        } else {
+            lingyi++
+        }
+        for (i in 1..<l) {
+            val cur = s.get(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)
+        }
+        var one = -1
+        var two = -1
+        for (cur in pq) {
+            if (cur > one) {
+                two = one
+                one = cur
+            } else if (cur > two) {
+                two = cur
+            }
+        }
+        if (two == -1) {
+            return if (one / (numOps + 1) > 1) one / (numOps + 1) else 2
+        }
+        if (numOps == 0) {
+            return one
+        }
+        if (numOps == 1) {
+            return if (one / 2 > two) (if (one / 2 == 1) 2 else one / 2) else two
+        }
+        var left = 2
+        var right = l / (numOps + 1)
+        while (left < right) {
+            val mid = left + (right - left) / 2
+            var sum = 0
+            for (integer in pq) {
+                sum += integer / (mid + 1)
+            }
+            if (sum <= numOps) {
+                right = mid
+            } else {
+                left = mid + 1
+            }
+        }
+        return left
+    }
+}

src/main/kotlin/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/kotlin/g3301_3400/s3398_smallest_substring_with_identical_characters_i/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g3301_3400.s3398_smallest_substring_with_identical_characters_i
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun minLength() {
+        assertThat<Int>(Solution().minLength("000001", 1), equalTo<Int>(2))
+    }
+
+    @Test
+    fun minLength2() {
+        assertThat<Int>(Solution().minLength("0000", 2), equalTo<Int>(1))
+    }
+
+    @Test
+    fun minLength3() {
+        assertThat<Int>(Solution().minLength("0101", 0), equalTo<Int>(1))
+    }
+}

src/test/kotlin/g3301_3400/s3399_smallest_substring_with_identical_characters_ii/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g3301_3400.s3399_smallest_substring_with_identical_characters_ii
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun minLength() {
+        assertThat<Int>(Solution().minLength("000001", 1), equalTo<Int>(2))
+    }
+
+    @Test
+    fun minLength2() {
+        assertThat<Int>(Solution().minLength("0000", 2), equalTo<Int>(1))
+    }
+
+    @Test
+    fun minLength3() {
+        assertThat<Int>(Solution().minLength("0101", 0), equalTo<Int>(1))
+    }
+}