Minimum Operations to Make Binary Array Elements Equal to One I

Minimum Operations to Make Binary Array Elements Equal to One I - Problem

Array Bit Manipulation Queue Sliding Window Prefix Sum Medium

Problem Statement:
You are given a binary array nums containing only 0s and 1s. Your goal is to make all elements in the array equal to 1 using a specific operation.

Operation: You can choose any 3 consecutive elements from the array and flip all of them. Flipping means changing 0 to 1 and 1 to 0.

Goal: Return the minimum number of operations required to make all elements equal to 1. If it's impossible to achieve this, return -1.

Example: For array [0,1,1,1,0,0], you can flip positions [0,1,2] to get [1,0,0,1,0,0], then flip [1,2,3] to get [1,1,1,0,1,1], and finally flip [3,4,5] to get [1,1,1,1,0,0].

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: We need 3 operations: 1) Flip [0,1,2] → [1,0,0,1,0,0], 2) Flip [1,2,3] → [1,1,1,0,1,1], 3) Flip [3,4,5] → [1,1,1,1,0,0]. Wait, this doesn't work. Let me recalculate: 1) Flip [0,1,2] → [1,0,0,1,0,0], 2) Flip [1,2,3] → [1,1,1,0,1,1], 3) Flip [3,4,5] → [1,1,1,1,0,0]. Actually: 1) [0,1,1] → [1,0,0], 2) [1,0,0] → [0,1,1], 3) [0,1,1] → [1,0,0]. The correct sequence is more complex but results in 3 operations.

example_2.py — Already All Ones

$ Input: [1,1,1]

› Output: 0

💡 Note: Array is already all ones, so no operations needed.

example_3.py — Impossible Case

$ Input: [0,1,0]

› Output: -1

💡 Note: With only 3 elements, we can only flip all of them at once: [0,1,0] → [1,0,1]. We still have a 0, and no more moves possible, so it's impossible.

Constraints

3 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1
You can only flip exactly 3 consecutive elements at a time

Visualization

Tap to expand

Understanding the Visualization

Scan Left to Right

Move your attention from leftmost switch to the right

Find OFF Switch

When you find an OFF switch, you must act immediately

Apply Tool

Use your 3-switch tool starting from the OFF switch position

Continue Process

Keep scanning right until you've processed all switches

Key Takeaway

🎯 Key Insight: The greedy approach works because when we find a 0, we must flip starting from that position immediately - it's our only opportunity to turn that specific 0 into a 1!

Asked in

G Google 23 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal solution uses a greedy left-to-right approach. When we encounter a 0, we must flip the 3-element window starting from that position since it's our only chance to fix it. This achieves O(n) time complexity with O(1) space, making it much more efficient than brute force approaches.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Left-to-Right (Optimal)	O(n)	O(1)	Process array left to right, flipping whenever we encounter a 0

Greedy Left-to-Right (Optimal) — Algorithm Steps

Iterate through array from left to right
When we find a 0, flip the 3-element window starting from that position
Continue until we reach the end
Check if all elements are 1
Return operation count or -1 if impossible

Visualization

Tap to expand

Step-by-Step Walkthrough

Find First Zero

Scan from left and find the first 0 at position i

Flip Window

Flip the 3-element window [i, i+1, i+2]

Continue Scanning

Move to the next position and repeat

Final Check

Verify all elements are 1, return operations count or -1

Code -

solution.c — C

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

int minOperations(int* nums, int size) {
    int operations = 0;
    
    // Process from left to right
    for (int i = 0; i <= size - 3; i++) {
        if (nums[i] == 0) {
            // Must flip the window [i, i+1, i+2]
            for (int j = 0; j < 3; j++) {
                nums[i + j] = 1 - nums[i + j];
            }
            operations++;
        }
    }
    
    // Check if all elements are 1
    for (int i = 0; i < size; i++) {
        if (nums[i] != 1) return -1;
    }
    
    return operations;
}

int main() {
    int nums[1000];
    int size = 0;
    
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    char* token = strtok(input, "[,]\n ");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[,]\n ");
    }
    
    printf("%d\n", minOperations(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each element processed once

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counting operations

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

847 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

Greedy Left-to-Right (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler