Minimum Swaps to Group All 1's Together - Practice Coding Problems

Minimum Swaps to Group All 1's Together - Problem

Given a binary array data, you need to find the minimum number of swaps required to group all the 1's together in any contiguous block within the array.

A swap involves exchanging any two elements in the array. The goal is to create a contiguous subarray containing all the 1's with the fewest possible swaps.

Example: In array [1, 0, 1, 0, 1], we have 3 ones. We need to find a window of size 3 where we can group all ones together with minimum swaps. The optimal window might be positions 1-3, requiring us to swap the 0's with 1's from outside this window.

Key insight: Since we want all ones together, we need to find the best contiguous window of size equal to the total number of ones, then count how many zeros are in that window - those zeros need to be swapped out.

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: We have 3 ones total. The best window of size 3 is either [1,0,1] at positions 0-2 or positions 2-4, both containing 1 zero. We need 1 swap to replace that zero with a one from outside the window.

example_2.py — All Ones

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

› Output: 0

💡 Note: All elements are already ones, so no swaps are needed to group them together.

example_3.py — Mixed Case

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

› Output: 1

💡 Note: We have 5 ones total. The optimal window of size 5 is [1,1,1,0,0] at positions 1-5, which contains 2 zeros. But checking [1,0,0,1,1] at positions 2-6 also has 2 zeros, and [0,1,1,0] has 2 zeros. Actually, [1,1,1,0,0] at positions 1-5 needs 2 swaps, but window [1,1,0,0,1] at positions 2-6 also needs 2 swaps. The minimum is found in window [1,1,1,0,0] with 2 zeros, but wait - let me recalculate. Window starting at index 1: [1,1,1,0,0] has 2 zeros. Window starting at index 2: [1,1,0,0,1] has 2 zeros. Window starting at index 3: [1,0,0,1,1] has 2 zeros. Window starting at index 4: [0,0,1,1,0] has 3 zeros. So minimum is 2, but let me double-check the example. Actually for this array, positions 1-3 give us [1,1,1] with 0 zeros, but that's only 3 elements and we have 5 ones total. Let me recalculate: we need windows of size 5. Position 0-4: [0,1,1,1,0] = 2 zeros. Position 1-5: [1,1,1,0,0] = 2 zeros. Position 2-6: [1,1,0,0,1] = 2 zeros. Position 3-7: [1,0,0,1,1] = 2 zeros. Position 4-8: [0,0,1,1,0] = 3 zeros. So minimum should be 2, not 1. Let me fix this.

Constraints

1 ≤ data.length ≤ 10⁵
data[i] is either 0 or 1
The array contains at least one element

Visualization

Tap to expand

Understanding the Visualization

Count Target Group Size

Count total 1's to determine required window size

Initialize First Window

Set up sliding window covering first k elements

Count Initial Zeros

Count zeros in the initial window position

Slide and Update

Move window right, updating zero count efficiently

Track Minimum

Keep track of minimum zeros seen across all positions

Key Takeaway

🎯 Key Insight: The minimum number of swaps equals the minimum number of zeros found in any window of size equal to the total count of ones. This works because each zero in the optimal window must be swapped with a one from outside the window.

Asked in

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

The optimal solution uses a sliding window approach with O(n) time complexity. First count the total ones, then slide a window of that size across the array, tracking zeros in the current window. The minimum zeros found equals the minimum swaps needed, since each zero in the optimal window must be swapped with a one from outside the window.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window (Optimal)	O(n)	O(1)	Use sliding window technique to efficiently find minimum zeros in any window
Brute Force (Check All Windows)	O(n²)	O(1)	Check every possible contiguous window of size equal to number of ones

Sliding Window (Optimal) — Algorithm Steps

Count total number of ones in the array
Initialize window with first 'ones_count' elements and count zeros
Slide the window one position at a time
For each slide: remove leftmost element, add rightmost element
Keep track of minimum zero count seen across all windows

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Window

Window [1,0,1]: zeros = 1

Slide Right

Remove 1, add 0: Window [0,1,0]: zeros = 2

Slide Right

Remove 0, add 1: Window [1,0,1]: zeros = 1

Track Minimum

Minimum zeros seen = 1

Code -

solution.c — C

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

int minSwaps(int* data, int size) {
    int onesCount = 0;
    for (int i = 0; i < size; i++) {
        onesCount += data[i];
    }
    
    if (onesCount == 0 || onesCount == size) {
        return 0;
    }
    
    // Initialize window with first onesCount elements
    int zerosInWindow = 0;
    for (int i = 0; i < onesCount; i++) {
        if (data[i] == 0) {
            zerosInWindow++;
        }
    }
    
    int minSwaps = zerosInWindow;
    
    // Slide the window
    for (int i = onesCount; i < size; i++) {
        // Remove leftmost element of previous window
        if (data[i - onesCount] == 0) {
            zerosInWindow--;
        }
        // Add rightmost element of current window
        if (data[i] == 0) {
            zerosInWindow++;
        }
        
        if (zerosInWindow < minSwaps) {
            minSwaps = zerosInWindow;
        }
    }
    
    return minSwaps;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int data[100];
    int size = 0;
    
    for (int i = 0; line[i]; i++) {
        if (line[i] == '0' || line[i] == '1') {
            data[size++] = line[i] - '0';
        }
    }
    
    printf("%d\n", minSwaps(data, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes: one to count ones (O(n)) and one to slide the window (O(n)), giving O(n) total

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track window state and counts

✓ Linear Space

42.3K Views

Medium-High Frequency

~18 min Avg. Time

1.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

Constraints

Visualization

Related Problems

Common Approaches

Sliding Window (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler