Added tasks 2379, 2380.

Author: javadev

README.md

@@ -1848,6 +1848,8 @@ implementation 'com.github.javadev:leetcode-in-java:1.12'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2380 |[Time Needed to Rearrange a Binary String](src/main/java/g2301_2400/s2380_time_needed_to_rearrange_a_binary_string/Solution.java)| Medium | String, Dynamic_Programming, Simulation | 3 | 70.00
+| 2379 |[Minimum Recolors to Get K Consecutive Black Blocks](src/main/java/g2301_2400/s2379_minimum_recolors_to_get_k_consecutive_black_blocks/Solution.java)| Easy | String, Sliding_Window | 1 | 80.00
 | 2376 |[Count Special Integers](src/main/java/g2301_2400/s2376_count_special_integers/Solution.java)| Hard | Dynamic_Programming, Math | 0 | 100.00
 | 2375 |[Construct Smallest Number From DI String](src/main/java/g2301_2400/s2375_construct_smallest_number_from_di_string/Solution.java)| Medium | String, Greedy, Stack, Backtracking | 0 | 100.00
 | 2374 |[Node With Highest Edge Score](src/main/java/g2301_2400/s2374_node_with_highest_edge_score/Solution.java)| Medium | Hash_Table, Graph | 4 | 97.68

src/main/java/g2301_2400/s2379_minimum_recolors_to_get_k_consecutive_black_blocks/Solution.java

@@ -0,0 +1,28 @@
+package g2301_2400.s2379_minimum_recolors_to_get_k_consecutive_black_blocks;
+
+// #Easy #String #Sliding_Window #2022_08_23_Time_1_ms_(80.00%)_Space_42.2_MB_(20.00%)
+
+public class Solution {
+    public int minimumRecolors(String blocks, int k) {
+        int n = blocks.length();
+        int ans;
+        int i;
+        int cur = 0;
+        for (i = 0; i < k; i++) {
+            if (blocks.charAt(i) == 'W') {
+                cur++;
+            }
+        }
+        ans = cur;
+        for (i = k; i < n; i++) {
+            if (blocks.charAt(i) == 'W') {
+                cur++;
+            }
+            if (blocks.charAt(i - k) == 'W') {
+                cur--;
+            }
+            ans = Math.min(ans, cur);
+        }
+        return ans;
+    }
+}

src/main/java/g2301_2400/s2379_minimum_recolors_to_get_k_consecutive_black_blocks/readme.md

@@ -0,0 +1,44 @@
+2379\. Minimum Recolors to Get K Consecutive Black Blocks
+
+Easy
+
+You are given a **0-indexed** string `blocks` of length `n`, where `blocks[i]` is either `'W'` or `'B'`, representing the color of the <code>i<sup>th</sup></code> block. The characters `'W'` and `'B'` denote the colors white and black, respectively.
+
+You are also given an integer `k`, which is the desired number of **consecutive** black blocks.
+
+In one operation, you can **recolor** a white block such that it becomes a black block.
+
+Return _the **minimum** number of operations needed such that there is at least **one** occurrence of_ `k` _consecutive black blocks._
+
+**Example 1:**
+
+**Input:** blocks = "WBBWWBBWBW", k = 7
+
+**Output:** 3
+
+**Explanation:**
+
+One way to achieve 7 consecutive black blocks is to recolor the 0th, 3rd, and 4th blocks so that blocks = "BBBBBBBWBW".
+
+It can be shown that there is no way to achieve 7 consecutive black blocks in less than 3 operations.
+
+Therefore, we return 3.
+
+**Example 2:**
+
+**Input:** blocks = "WBWBBBW", k = 2
+
+**Output:** 0
+
+**Explanation:**
+
+No changes need to be made, since 2 consecutive black blocks already exist.
+
+Therefore, we return 0. 
+
+**Constraints:**
+
+*   `n == blocks.length`
+*   `1 <= n <= 100`
+*   `blocks[i]` is either `'W'` or `'B'`.
+*   `1 <= k <= n`

src/main/java/g2301_2400/s2380_time_needed_to_rearrange_a_binary_string/Solution.java

@@ -0,0 +1,39 @@
+package g2301_2400.s2380_time_needed_to_rearrange_a_binary_string;
+
+// #Medium #String #Dynamic_Programming #Simulation
+// #2022_08_23_Time_3_ms_(70.00%)_Space_41.8_MB_(70.00%)
+
+public class Solution {
+    public int secondsToRemoveOccurrences(String s) {
+        int lastOne = -1;
+        int result = 0;
+        int prevResult = 0;
+        int curResult = 0;
+        int countOne = 0;
+        int countZero = 0;
+        int diff;
+        int pTarget;
+        int pWait;
+        int cTarget;
+        for (int i = 0; i < s.length(); ++i) {
+            if (s.charAt(i) == '0') {
+                ++countZero;
+                continue;
+            }
+            ++countOne;
+            diff = i - lastOne - 1;
+            prevResult = curResult;
+            cTarget = countOne - 1;
+            pTarget = cTarget - 1;
+            pWait = prevResult - (lastOne - pTarget);
+            if (diff > pWait) {
+                curResult = countZero;
+            } else {
+                curResult = countZero == 0 ? 0 : pWait - diff + 1 + countZero;
+            }
+            result = curResult;
+            lastOne = i;
+        }
+        return result;
+    }
+}

src/main/java/g2301_2400/s2380_time_needed_to_rearrange_a_binary_string/readme.md

@@ -0,0 +1,42 @@
+2380\. Time Needed to Rearrange a Binary String
+
+Medium
+
+You are given a binary string `s`. In one second, **all** occurrences of `"01"` are **simultaneously** replaced with `"10"`. This process **repeats** until no occurrences of `"01"` exist.
+
+Return _the number of seconds needed to complete this process._
+
+**Example 1:**
+
+**Input:** s = "0110101"
+
+**Output:** 4
+
+**Explanation:**
+
+After one second, s becomes "1011010".
+
+After another second, s becomes "1101100".
+
+After the third second, s becomes "1110100".
+
+After the fourth second, s becomes "1111000".
+
+No occurrence of "01" exists any longer, and the process needed 4 seconds to complete, so we return 4.
+
+**Example 2:**
+
+**Input:** s = "11100"
+
+**Output:** 0
+
+**Explanation:** No occurrence of "01" exists in s, and the processes needed 0 seconds to complete, so we return 0.
+
+**Constraints:**
+
+*   `1 <= s.length <= 1000`
+*   `s[i]` is either `'0'` or `'1'`.
+
+**Follow up:**
+
+Can you solve this problem in O(n) time complexity?

src/test/java/g2301_2400/s2379_minimum_recolors_to_get_k_consecutive_black_blocks/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2301_2400.s2379_minimum_recolors_to_get_k_consecutive_black_blocks;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void minimumRecolors() {
+        assertThat(new Solution().minimumRecolors("WBBWWBBWBW", 7), equalTo(3));
+    }
+
+    @Test
+    void minimumRecolors2() {
+        assertThat(new Solution().minimumRecolors("WBWBBBW", 2), equalTo(0));
+    }
+}

src/test/java/g2301_2400/s2380_time_needed_to_rearrange_a_binary_string/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2301_2400.s2380_time_needed_to_rearrange_a_binary_string;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void secondsToRemoveOccurrences() {
+        assertThat(new Solution().secondsToRemoveOccurrences("0110101"), equalTo(4));
+    }
+
+    @Test
+    void secondsToRemoveOccurrences2() {
+        assertThat(new Solution().secondsToRemoveOccurrences("11100"), equalTo(0));
+    }
+}