Minimum Number of K Consecutive Bit Flips

Minimum Number of K Consecutive Bit Flips - Problem

Array Bit Manipulation Queue Sliding Window Prefix Sum Hard

Imagine you have a binary array where each element is either 0 or 1, and your goal is to make all elements become 1. However, you can't change individual bits - you can only perform k-bit flips!

A k-bit flip allows you to select any contiguous subarray of length k and flip every bit in it (0 becomes 1, 1 becomes 0). For example, if k=3 and you have [0,1,0,1,1], you could flip the first 3 elements to get [1,0,1,1,1].

Your mission: Find the minimum number of k-bit flips needed to make all elements equal to 1. If it's impossible, return -1.

Key Challenge: The order of operations matters! Flipping the same region twice cancels out, and you need to think strategically about which regions to flip to achieve the optimal solution.

Input & Output

example_1.py — Basic flip operation

$ Input: nums = [0,1,0], k = 1

› Output: 2

💡 Note: Flip nums[0], then flip nums[2]. Each flip changes exactly one element since k=1. After both flips: [1,1,1]

example_2.py — Impossible case

$ Input: nums = [1,1,0], k = 2

› Output: -1

💡 Note: The last element is 0, but we can't flip a subarray of length 2 starting at index 2 (would need index 3). Since we can only flip [0,1] or [1,2], and flipping [1,2] makes nums[1] become 0, it's impossible.

example_3.py — Multiple flips needed

$ Input: nums = [0,0,0,1,0,1,1,0], k = 3

› Output: 3

💡 Note: Starting with [0,0,0,1,0,1,1,0], we need 3 flips: at positions 0, 4, and 5 to get all 1s.

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Some lights are OFF (0) and some are ON (1)

Scan Left to Right

Move your controller from left to right

Flip When Needed

When you find an OFF light, flip k switches starting there

Check Feasibility

If you can't fit k switches, it's impossible

Key Takeaway

🎯 Key Insight: The greedy left-to-right approach works because if we need to flip a 0 at position i, starting the flip at position i is always optimal - it fixes the current problem without creating unnecessary complications later.

Time & Space Complexity

Time Complexity

⏱️

O(n*k)

We scan the array once (O(n)) and for each 0, we may flip k elements (O(k))

✓ Linear Growth

Space Complexity

O(1)

We modify the array in-place, using only constant extra space

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ k ≤ nums.length
nums[i] is either 0 or 1

Asked in

G Google 25 f Meta 18 ⊞ Microsoft 12 a Amazon 8

The optimal solution uses a greedy approach scanning left-to-right. When we encounter a 0, we must flip it, and the optimal strategy is always to start the k-flip at the leftmost position. This ensures we make the minimum number of flips. The key insight is that order matters - we process from left to right because earlier decisions affect later positions.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach (Optimal)	O(n*k)	O(1)	Scan left to right, flip whenever we encounter a 0

Greedy Approach (Optimal) — Algorithm Steps

Scan the array from left to right
When we encounter a 0 at position i, check if we can perform a k-flip starting at i
If i + k > n, it's impossible to flip this 0, so return -1
Otherwise, flip the k consecutive elements starting at position i
Continue until we've processed the entire array
Return the total number of flips performed

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan Left to Right

Move through array looking for 0s

Flip When Needed

When we find a 0, flip k elements starting there

Continue Until Done

Process entire array, count total flips

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int minKBitFlips(int* nums, int numsSize, int k) {
    int flips = 0;
    
    for (int i = 0; i < numsSize; i++) {
        // If current element is 0, we must flip
        if (nums[i] == 0) {
            // Check if we can perform a k-flip starting at i
            if (i + k > numsSize) {
                return -1; // Impossible to flip
            }
            
            // Perform the k-flip
            for (int j = i; j < i + k; j++) {
                nums[j] = 1 - nums[j];
            }
            
            flips++;
        }
    }
    
    return flips;
}

int main() {
    int nums[] = {0, 1, 0};
    int k = 1;
    printf("%d\n", minKBitFlips(nums, 3, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*k)

We scan the array once (O(n)) and for each 0, we may flip k elements (O(k))

✓ Linear Growth

Space Complexity

O(1)

We modify the array in-place, using only constant extra space

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ k ≤ nums.length
nums[i] is either 0 or 1

23.4K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Greedy Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler