Minimum Swaps to Group All 1's Together

Minimum Swaps to Group All 1's Together - Problem

Given a binary array data, return the minimum number of swaps required to group all 1's present in the array together in any place in the array.

A swap is defined as exchanging the positions of any two elements in the array. The goal is to make all 1's contiguous (adjacent to each other) with the minimum number of swaps.

Note: The 1's can be grouped anywhere in the array - at the beginning, middle, or end.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: We have 3 ones total. The optimal window is either [1,0,1] at positions 0-2 or 2-4, both containing 2 ones and 1 zero. We need 1 swap to make it all ones.

Example 2 — Already Grouped

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

› Output: 0

💡 Note: All 3 ones are already grouped together at positions 2-4, so no swaps needed.

Example 3 — All Zeros or Ones

$ Input: data = [1,1,1,1]

› Output: 0

💡 Note: All elements are 1s, so they're already grouped together.

Constraints

1 ≤ data.length ≤ 10⁵
data[i] is either 0 or 1

Visualization

Tap to expand

Asked in

M Microsoft 35 A Amazon 28 F Facebook 22 G Google 18

The key insight is to find the window of size equal to the number of 1's that contains the maximum number of 1's already. The minimum swaps needed equals the window size minus the maximum 1's found in any window. Best approach uses sliding window technique for O(n) time complexity. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Try All Positions

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

For each possible starting position where we could group all 1's, calculate how many swaps are needed to move all 1's to that contiguous block. Return the minimum across all positions.

Sliding Window Optimization

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

Instead of recalculating each window from scratch, maintain a sliding window of size equal to the number of 1's. As we slide the window, we can efficiently update the count of 1's in the current window. The window with the most 1's requires the fewest swaps.

Brute Force - Try All Positions — Algorithm Steps

Count total number of 1's in array
For each possible starting position, calculate swaps needed
Track minimum swaps across all positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Count 1's

Find total ones = 3, so window size = 3

Try Position 0

Window [1,0,1] has 1 zero → 1 swap needed

Try Position 1

Window [0,1,0] has 2 zeros → 2 swaps needed

Try Position 2

Window [1,0,1] has 1 zero → 1 swap needed

Minimum

Return minimum = 1 swap

Code -

solution.c — C

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

int solution(int* data, int size) {
    int onesCount = 0;
    for (int i = 0; i < size; i++) {
        onesCount += data[i];
    }
    
    if (onesCount <= 1) {
        return 0;
    }
    
    int minSwaps = INT_MAX;
    
    // Try each possible starting position for the group
    for (int start = 0; start <= size - onesCount; start++) {
        int swaps = 0;
        // Count how many 0's are in this window
        for (int i = start; i < start + onesCount; i++) {
            if (data[i] == 0) {
                swaps++;
            }
        }
        if (swaps < minSwaps) {
            minSwaps = swaps;
        }
    }
    
    return minSwaps;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array
    int data[1000];
    int size = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        data[size++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(data, size);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we scan the window of size k (number of 1's)

✓ Linear Growth

Space Complexity

O(1)

Only using variables for counting, no extra data structures

✓ Linear Space

28.5K Views

Medium Frequency

~15 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 - Try All Positions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler