Max Consecutive Ones II - Practice Coding Problems

Max Consecutive Ones II - Problem

Given a binary array nums containing only 0s and 1s, you have the power to flip at most one zero to become a one. Your goal is to find the maximum number of consecutive 1's you can achieve after performing this operation.

Think of it as optimizing a sequence - you can strategically choose which zero (if any) to flip to create the longest possible chain of ones. If the array contains no zeros, you simply return the length of the entire array.

Examples:

[1,0,1,1,0] → Flip the first 0 → [1,1,1,1,0] → Answer: 4
[1,0,1,1,0,1] → Flip the middle 0 → [1,0,1,1,1,1] → Answer: 4

Input & Output

example_1.py — Standard Case

$ Input: [1,0,1,1,0]

› Output: 4

💡 Note: Flip the first 0 to get [1,1,1,1,0], giving us 4 consecutive ones at the beginning

example_2.py — Multiple Options

$ Input: [1,0,1,1,0,1]

› Output: 4

💡 Note: We can flip either the first 0 to get [1,1,1,1,0,1] or the second 0 to get [1,0,1,1,1,1]. Both give us 4 consecutive ones maximum

example_3.py — All Ones

$ Input: [1,1,1]

› Output: 3

💡 Note: Array has no zeros to flip, so we return the length of the entire array

Visualization

Tap to expand

Understanding the Visualization

Survey the Terrain

Look at your bridge sections and identify where the gaps are located

Use Sliding Window

Create a flexible measuring window that can contain at most one gap

Expand Wisely

Grow your window to include more sections, keeping track of gaps

Contract When Needed

When you encounter a second gap, shrink the window from the left

Track the Maximum

Remember the longest bridge you can build throughout the process

Key Takeaway

🎯 Key Insight: Instead of trying every possible flip position, use a sliding window that maintains at most one zero. This reduces the time complexity from O(n²) to O(n) while using constant space.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the n positions, we scan the entire array to find max consecutive ones

⚠ Quadratic Growth

Space Complexity

O(n)

We create copies of the array for each flip attempt

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1
You can flip at most one 0 to 1

Asked in

G Google 12 f Meta 8 a Amazon 6 ⊞ Microsoft 4

The optimal solution uses a sliding window approach with two pointers. We maintain a window containing at most one zero, expanding it when possible and shrinking it when we encounter a second zero. This achieves O(n) time and O(1) space complexity, making it much more efficient than the brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Positions)	O(n²)	O(n)	Try flipping each zero and calculate consecutive ones for each case
Sliding Window (Two Pointers)	O(n)	O(1)	Use sliding window technique to maintain at most one zero in the window

Brute Force (Try All Positions) — Algorithm Steps

Find all positions of zeros in the array
For each zero position, create a copy of array with that zero flipped to 1
Calculate maximum consecutive ones for each modified array
Also calculate consecutive ones without flipping any zero
Return the maximum among all calculated values

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Array

Start with the original binary array

Try Flipping Each Zero

For each zero, flip it and calculate max consecutive ones

Track Maximum

Keep track of the best result found so far

Code -

solution.c — C

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

int maxConsecutive(int* arr, int size) {
    int maxCount = 0, currentCount = 0;
    for (int i = 0; i < size; i++) {
        if (arr[i] == 1) {
            currentCount++;
            if (currentCount > maxCount) {
                maxCount = currentCount;
            }
        } else {
            currentCount = 0;
        }
    }
    return maxCount;
}

int findMaxConsecutiveOnes(int* nums, int numsSize) {
    int result = maxConsecutive(nums, numsSize);
    
    // Try flipping each zero
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] == 0) {
            nums[i] = 1; // Flip
            int temp = maxConsecutive(nums, numsSize);
            if (temp > result) {
                result = temp;
            }
            nums[i] = 0; // Flip back
        }
    }
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    
    printf("%d\n", findMaxConsecutiveOnes(nums, n));
    free(nums);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the n positions, we scan the entire array to find max consecutive ones

⚠ Quadratic Growth

Space Complexity

O(n)

We create copies of the array for each flip attempt

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1
You can flip at most one 0 to 1

95.0K Views

Medium 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

Brute Force (Try All Positions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler