Minimum Adjacent Swaps for K Consecutive Ones

Minimum Adjacent Swaps for K Consecutive Ones - Problem

You're given a binary array nums containing only 0's and 1's, and an integer k. Your goal is to create a sequence of exactly k consecutive 1's using the minimum number of adjacent swaps.

In each move, you can swap two adjacent elements in the array. For example, if you have [0, 1, 0], you can swap positions 0 and 1 to get [1, 0, 0].

Challenge: Find the minimum number of swaps needed to group exactly k ones together consecutively anywhere in the array.

Example: Given nums = [1,0,0,1,0,1] and k = 2, you need at least 1 swap to get two consecutive 1's.

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: We have 1's at positions [0,3,5]. To get 2 consecutive 1's, the best strategy is to move the 1 from position 5 to position 4, requiring 1 swap: [1,0,0,1,1,0].

example_2.py — Multiple Options

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

› Output: 5

💡 Note: We have 1's at positions [0,6,7]. To group all 3 together, we need to move them to consecutive positions. The optimal is to create [0,0,1,1,1,0,0,0], requiring 5 swaps total.

example_3.py — Edge Case

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

› Output: 0

💡 Note: We already have 2 consecutive 1's at positions [0,1], so no swaps are needed.

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1
1 ≤ k ≤ sum(nums)
k consecutive 1's must be possible (enough 1's exist in array)

Visualization

Tap to expand

Understanding the Visualization

Identify Occupied Seats

Find all seats with people (1's) that need to be grouped together

Find Optimal Target Zone

Use sliding window to find the best consecutive seats to group people

Calculate Movement Cost

Use median principle: move people to positions around their median location

Execute Minimum Swaps

Perform the calculated minimum adjacent swaps to achieve the grouping

Key Takeaway

🎯 Key Insight: The median positioning principle minimizes total movement cost. By using a sliding window on the positions of 1's and calculating costs with prefix sums, we achieve an optimal O(n) solution that efficiently finds the minimum swaps needed to group k consecutive 1's.

Asked in

G Google 45 f Facebook 32 a Amazon 28 ⊞ Microsoft 21

The optimal solution uses a sliding window approach on the positions of 1's combined with the median optimization principle. Key insight: when grouping items to minimize total movement, place them around their median position. This achieves O(n) time complexity using prefix sums for efficient cost calculation.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Windows)	O(n²)	O(n)	Try every possible window of size k and calculate swaps needed for each
Sliding Window + Median Optimization	O(n)	O(n)	Use sliding window on 1's positions with median-based cost calculation

Brute Force (Try All Windows) — Algorithm Steps

Find all positions of 1's in the array
For each possible window of size k (n-k+1 windows total)
Calculate the cost to move k closest 1's to this window
Use the minimum cost among all windows

Visualization

Tap to expand

Step-by-Step Walkthrough

Find All 1's

Locate all positions containing 1's in the array

Test Window 1

Calculate cost to move k 1's to first possible window

Test Window 2

Calculate cost for next window position

Continue Testing

Test all possible windows and track minimum cost

Code -

solution.c — C

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

int minMoves(int* nums, int numsSize, int k) {
    if (k == 1) return 0;
    
    int* ones = (int*)malloc(numsSize * sizeof(int));
    int onesCount = 0;
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] == 1) {
            ones[onesCount++] = i;
        }
    }
    
    if (onesCount < k) {
        free(ones);
        return -1;
    }
    
    int minSwaps = INT_MAX;
    
    for (int start = 0; start <= numsSize - k; start++) {
        int swaps = 0;
        for (int i = 0; i < k; i++) {
            int diff = ones[i] - (start + i);
            swaps += (diff < 0) ? -diff : diff;
        }
        if (swaps < minSwaps) {
            minSwaps = swaps;
        }
    }
    
    free(ones);
    return minSwaps / 2;
}

int main() {
    int nums[1000];
    int numsSize = 0;
    int k;
    
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    char* token = strtok(line, " ");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    scanf("%d", &k);
    printf("%d\n", minMoves(nums, numsSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of O(n) windows, we calculate O(n) cost to assign 1's to positions

⚠ Quadratic Growth

Space Complexity

O(n)

Store positions of all 1's in the array

⚡ Linearithmic Space

43.5K Views

High Frequency

~25 min Avg. Time

1.9K 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 Windows) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler