Minimum Adjacent Swaps for K Consecutive Ones

Minimum Adjacent Swaps for K Consecutive Ones - Problem

You are given an integer array nums comprising only 0's and 1's, and an integer k.

In one move, you can choose two adjacent indices and swap their values.

Return the minimum number of moves required so that nums has k consecutive 1's.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: We can make 2 consecutive 1's by swapping positions 1 and 2: [1,1,0,0,1]. This takes 1 swap.

Example 2 — Already Consecutive

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

› Output: 2

💡 Note: The ones are at positions [0,2,4,6]. For any window of 3 ones, we need swaps to make them consecutive. The minimum cost is 2 swaps.

Example 3 — Larger Array

$ Input: nums = [1,1,0,1,0,1,1,1,1], k = 4

› Output: 2

💡 Note: Optimal to use the last 4 ones at positions [5,6,7,8]. Need 2 swaps to make them consecutive.

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is 0 or 1
1 ≤ k ≤ sum(nums)

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 a Amazon 15

The key insight is to find the optimal window of k 1's that requires minimum swaps to become consecutive. The sliding window with prefix sum approach efficiently calculates the cost for each possible window using median-based positioning. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force - Try All Positions

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

For each possible starting position, simulate moving k 1's to that position by counting how many 0's need to be swapped out. This requires checking every position and counting swaps for each.

Sliding Window with Prefix Sum

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

Instead of recalculating swaps for each window from scratch, use a sliding window approach with prefix sums to calculate the cost of moving 1's to consecutive positions efficiently.

Brute Force - Try All Positions — Algorithm Steps

Step 1: Extract positions of all 1's in the array
Step 2: For each possible window of size k, calculate swaps needed
Step 3: Return minimum swaps across all windows

Visualization

Tap to expand

Step-by-Step Walkthrough

Find All 1's

Extract positions of all 1's from the array

Try Each Window

For each group of k 1's, calculate swaps needed

Return Minimum

Find the window requiring minimum swaps

Code -

solution.c — C

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

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int min_val(int a, int b) {
    return a < b ? a : b;
}

int max_val(int a, int b) {
    return a > b ? a : b;
}

int solution(int* nums, int numsSize, int k) {
    if (k == 1) return 0;
    
    int* ones = 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;
    
    // Try each group of k consecutive 1's
    for (int i = 0; i <= onesCount - k; i++) {
        // Get the k ones we're considering
        int* selectedOnes = malloc(k * sizeof(int));
        for (int j = 0; j < k; j++) {
            selectedOnes[j] = ones[i + j];
        }
        
        // Try all possible starting positions
        int minCostForThisWindow = INT_MAX;
        
        // The optimal starting position is around the median
        int medianPos = selectedOnes[k / 2];
        
        // Check starting positions in a reasonable range
        for (int start = max_val(0, medianPos - k); start < min_val(numsSize - k + 1, medianPos + k); start++) {
            int cost = 0;
            for (int j = 0; j < k; j++) {
                cost += abs_val(selectedOnes[j] - (start + j));
            }
            minCostForThisWindow = min_val(minCostForThisWindow, cost);
        }
        
        minSwaps = min_val(minSwaps, minCostForThisWindow);
        free(selectedOnes);
    }
    
    free(ones);
    return minSwaps;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize;
    parseArray(line, nums, &numsSize);
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", solution(nums, numsSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we calculate swaps which takes O(n) time

✓ Linear Growth

Space Complexity

O(n)

Store positions of all 1's in separate array

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~35 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