Build confidence with an intuition-first walkthrough focused on sliding window fundamentals.
You are given a 0-indexed string blocks of length n, where blocks[i] is either 'W' or 'B', representing the color of the ith 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.length1 <= n <= 100blocks[i] is either 'W' or 'B'.1 <= k <= nProblem summary: You are given a 0-indexed string blocks of length n, where blocks[i] is either 'W' or 'B', representing the color of the ith 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.
Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.
Pattern signal: Sliding Window
"WBBWWBBWBW" 7
"WBWBBBW" 2
max-consecutive-ones-iii)maximum-points-you-can-obtain-from-cards)maximum-number-of-vowels-in-a-substring-of-given-length)Source-backed implementations are provided below for direct study and interview prep.
// Accepted solution for LeetCode #2379: Minimum Recolors to Get K Consecutive Black Blocks
class Solution {
public int minimumRecolors(String blocks, int k) {
int cnt = 0;
for (int i = 0; i < k; ++i) {
cnt += blocks.charAt(i) == 'W' ? 1 : 0;
}
int ans = cnt;
for (int i = k; i < blocks.length(); ++i) {
cnt += blocks.charAt(i) == 'W' ? 1 : 0;
cnt -= blocks.charAt(i - k) == 'W' ? 1 : 0;
ans = Math.min(ans, cnt);
}
return ans;
}
}
// Accepted solution for LeetCode #2379: Minimum Recolors to Get K Consecutive Black Blocks
func minimumRecolors(blocks string, k int) int {
cnt := strings.Count(blocks[:k], "W")
ans := cnt
for i := k; i < len(blocks); i++ {
if blocks[i] == 'W' {
cnt++
}
if blocks[i-k] == 'W' {
cnt--
}
if ans > cnt {
ans = cnt
}
}
return ans
}
# Accepted solution for LeetCode #2379: Minimum Recolors to Get K Consecutive Black Blocks
class Solution:
def minimumRecolors(self, blocks: str, k: int) -> int:
ans = cnt = blocks[:k].count('W')
for i in range(k, len(blocks)):
cnt += blocks[i] == 'W'
cnt -= blocks[i - k] == 'W'
ans = min(ans, cnt)
return ans
// Accepted solution for LeetCode #2379: Minimum Recolors to Get K Consecutive Black Blocks
impl Solution {
pub fn minimum_recolors(blocks: String, k: i32) -> i32 {
let k = k as usize;
let s = blocks.as_bytes();
let n = s.len();
let mut count = 0;
for i in 0..k {
if s[i] == b'B' {
count += 1;
}
}
let mut ans = k - count;
for i in k..n {
if s[i - k] == b'B' {
count -= 1;
}
if s[i] == b'B' {
count += 1;
}
ans = ans.min(k - count);
}
ans as i32
}
}
// Accepted solution for LeetCode #2379: Minimum Recolors to Get K Consecutive Black Blocks
function minimumRecolors(blocks: string, k: number): number {
let cnt = 0;
for (let i = 0; i < k; ++i) {
cnt += blocks[i] === 'W' ? 1 : 0;
}
let ans = cnt;
for (let i = k; i < blocks.length; ++i) {
cnt += blocks[i] === 'W' ? 1 : 0;
cnt -= blocks[i - k] === 'W' ? 1 : 0;
ans = Math.min(ans, cnt);
}
return ans;
}
Use this to step through a reusable interview workflow for this problem.
For each starting index, scan the next k elements to compute the window aggregate. There are n−k+1 starting positions, each requiring O(k) work, giving O(n × k) total. No extra space since we recompute from scratch each time.
The window expands and contracts as we scan left to right. Each element enters the window at most once and leaves at most once, giving 2n total operations = O(n). Space depends on what we track inside the window (a hash map of at most k distinct elements, or O(1) for a fixed-size window).
Review these before coding to avoid predictable interview regressions.
Wrong move: Using `if` instead of `while` leaves the window invalid for multiple iterations.
Usually fails on: Over-limit windows stay invalid and produce wrong lengths/counts.
Fix: Shrink in a `while` loop until the invariant is valid again.