Minimum Number of K Consecutive Bit Flips

Minimum Number of K Consecutive Bit Flips - Problem

Array Bit Manipulation Queue Sliding Window Prefix Sum Hard

You are given a binary array nums and an integer k. A k-bit flip is choosing a subarray of length k from nums and simultaneously changing every 0 in the subarray to 1, and every 1 in the subarray to 0.

Return the minimum number of k-bit flips required so that there is no 0 in the array. If it is not possible, return -1.

A subarray is a contiguous part of an array.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: Flip nums[0] to get [1,1,0], then flip nums[2] to get [1,1,1]. Total 2 flips needed.

Example 2 — Larger K

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

› Output: -1

💡 Note: No matter how we flip, we cannot make all elements 1. The last element cannot be covered by any valid 2-flip.

Example 3 — Multiple Flips

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

› Output: 3

💡 Note: Flip [0,0,0] to [1,1,1], flip [0,1,1] to [1,0,0], flip [0,0,x] at the end. Total 3 flips.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ k ≤ nums.length

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 a Amazon 12

The key insight is to use a differential array to efficiently track when flip effects start and end, avoiding the need to actually flip bits or maintain a queue. The optimal approach processes each position in O(1) time. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(n*k) Space: O(1)

For each position with a 0, perform a k-flip by inverting all k consecutive bits. Count the number of flips needed.

Differential Array Optimization

⏱️ Time: O(n) Space: O(n)

Instead of maintaining a queue, use a differential array to mark when flips start and end, then compute running sum to get active flip count.

Sliding Window with Flip Counter

⏱️ Time: O(n) Space: O(n)

Instead of actually flipping bits, track how many flips are currently affecting each position using a sliding window approach.

Brute Force Simulation — Algorithm Steps

Scan array from left to right
When we find a 0, flip k consecutive bits
Count total flips needed
Return count if all bits are 1, else -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Find First 0

Scan from left until we find a 0

Flip K Bits

Flip k consecutive bits starting from the 0

Repeat

Continue until no more 0s or impossible

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int k) {
    // Make a copy to avoid modifying original
    int* arr = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        arr[i] = nums[i];
    }
    
    int flips = 0;
    
    for (int i = 0; i <= numsSize - k; i++) {
        if (arr[i] == 0) {
            // Flip k consecutive bits starting at i
            for (int j = i; j < i + k; j++) {
                arr[j] = 1 - arr[j];
            }
            flips++;
        }
    }
    
    // Check if all bits are 1
    for (int i = 0; i < numsSize; i++) {
        if (arr[i] == 0) {
            free(arr);
            return -1;
        }
    }
    
    free(arr);
    return flips;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", solution(nums, numsSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*k)

For each of n positions, we might perform k flips

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

28.5K Views

Medium Frequency

~35 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler