Max Consecutive Ones III - Practice Coding Problems

Max Consecutive Ones III - Problem

Imagine you have a binary array filled with 0s and 1s, and you're given a special power: you can flip at most k zeros into ones. Your mission is to find the maximum number of consecutive 1s you can create using this power strategically.

Given a binary array nums and an integer k, return the length of the longest subarray containing only 1s after flipping at most k zeros.

Example: If you have [1,1,1,0,0,0,1,1,1,1,0] and k = 2, you could flip the zeros at positions 3 and 4 to get [1,1,1,1,1,0,1,1,1,1,0], creating 5 consecutive ones. But there's an even better strategy!

Input & Output

example_1.py — Basic Case

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

› Output: 6

💡 Note: We can flip the zeros at indices 4 and 5 to get [1,1,1,0,0,1,1,1,1,1,0], creating a sequence of 6 consecutive ones from index 5 to 10. Alternatively, flipping indices 3 and 4 gives us [1,1,1,1,1,0,1,1,1,1,0] with 5 consecutive ones, but 6 is better.

example_2.py — All Zeros Case

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

› Output: 10

💡 Note: We can flip 3 zeros strategically to create the longest possible sequence. By flipping zeros at positions that connect existing sequences of ones, we can achieve a maximum length of 10.

example_3.py — No Flips Needed

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

› Output: 4

💡 Note: The array already contains all ones, so no flips are needed. The maximum consecutive ones is the entire array length of 4.

Visualization

Tap to expand

Understanding the Visualization

Start with a measuring tape

Place your measuring tape at the beginning (left pointer) and start extending it (right pointer)

Count bridge segments used

As you encounter water gaps (0s), use bridge segments. Keep track of how many you've used

Retract when over budget

When you've used more than k segments, pull back the left end of your tape until you're within budget

Record maximum span

Throughout this process, keep track of the longest valid span you've measured

Key Takeaway

🎯 Key Insight: The sliding window technique allows us to find the optimal solution in O(n) time by maintaining a valid window that never contains more than k zeros, expanding and contracting as needed.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Binary search runs in O(log n) iterations, each checking O(n) subarrays

⚡ Linearithmic

Space Complexity

O(1)

Only using variables for binary search bounds and counting

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1
0 ≤ k ≤ nums.length
Follow up: Can you solve this in O(n) time and O(1) space?

Asked in

f Meta 45 a Amazon 38 G Google 32 ⊞ Microsoft 25

The optimal solution uses a sliding window (two pointers) approach. We maintain a window that contains at most k zeros, expanding the right boundary and contracting the left boundary as needed. This achieves O(n) time complexity with O(1) space, making it the most efficient solution for this problem.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Answer	O(n log n)	O(1)	Binary search on the answer length, checking if each length is achievable
Sliding Window (Two Pointers)	O(n)	O(1)	Use two pointers to maintain a valid window with at most k zeros
Brute Force (Check All Subarrays)	O(n²)	O(1)	Check every possible subarray and count zeros in each

Binary Search on Answer — Algorithm Steps

Binary search on possible lengths from 1 to n
For each mid length, check if any subarray of that length has ≤ k zeros
Use sliding window to efficiently count zeros in each subarray
If achievable, search for larger lengths; otherwise search for smaller ones
Return the maximum achievable length

Visualization

Tap to expand

Step-by-Step Walkthrough

Set bounds

left=1, right=n (possible lengths)

Test middle

Check if length=mid is achievable

Adjust search

If achievable, search larger; else search smaller

Find maximum

Continue until we find the maximum achievable length

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>

bool canAchieveLength(int* nums, int numsSize, int k, int length) {
    int zerosCount = 0;
    
    // Check first window
    for (int i = 0; i < length; i++) {
        if (nums[i] == 0) zerosCount++;
    }
    
    if (zerosCount <= k) return true;
    
    // Slide window
    for (int i = length; i < numsSize; i++) {
        if (nums[i] == 0) zerosCount++;
        if (nums[i - length] == 0) zerosCount--;
        if (zerosCount <= k) return true;
    }
    
    return false;
}

int longestOnes(int* nums, int numsSize, int k) {
    int left = 1, right = numsSize;
    int result = 0;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (canAchieveLength(nums, k, mid)) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Binary search runs in O(log n) iterations, each checking O(n) subarrays

⚡ Linearithmic

Space Complexity

O(1)

Only using variables for binary search bounds and counting

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1
0 ≤ k ≤ nums.length
Follow up: Can you solve this in O(n) time and O(1) space?

58.9K Views

High Frequency

~15 min Avg. Time

2.8K 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

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler