Minimum Adjacent Swaps to Alternate Parity

Minimum Adjacent Swaps to Alternate Parity - Problem

Array Greedy Medium

Imagine you have an array of distinct integers where you need to arrange them in a specific pattern - every adjacent pair must have alternating parity (one even, one odd).

You can perform adjacent swaps - swapping any two neighboring elements in a single operation. Your goal is to find the minimum number of swaps needed to create a valid alternating pattern.

For example, in array [1, 2, 3, 4], a valid arrangement could be [1, 2, 3, 4] (odd-even-odd-even) or [2, 1, 4, 3] (even-odd-even-odd). Both patterns are acceptable!

Return: The minimum number of adjacent swaps needed, or -1 if it's impossible to create any valid alternating arrangement.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1, 2, 3, 4]

› Output: 0

💡 Note: The array is already alternating: odd-even-odd-even. No swaps needed.

example_2.py — Requires Swaps

$ Input: nums = [1, 3, 2, 4]

› Output: 1

💡 Note: We need to swap elements at positions 1 and 2 to get [1, 2, 3, 4] which alternates odd-even-odd-even.

example_3.py — Impossible Case

$ Input: nums = [1, 3, 5, 7]

› Output: -1

💡 Note: All numbers are odd, so we cannot create an alternating pattern of odd-even. Return -1.

Constraints

1 ≤ nums.length ≤ 10³
1 ≤ nums[i] ≤ 10⁵
All elements in nums are distinct
You can only swap adjacent elements

Visualization

Tap to expand

Understanding the Visualization

Count Dancers

First, count how many tall vs short dancers we have

Check Possibility

For alternating pattern, counts can differ by at most 1

Try Both Patterns

Test starting with tall-short vs short-tall pattern

Calculate Swaps

For each pattern, count adjacent swaps needed

Choose Minimum

Return the pattern requiring fewer swaps

Key Takeaway

🎯 Key Insight: Since there are only two possible alternating patterns (odd-even or even-odd starting), we can try both and choose the one requiring minimum swaps, making this much more efficient than brute force!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal approach recognizes that only two alternating patterns are possible: odd-even-odd-even or even-odd-even-odd. We separate numbers by parity, check if alternating is possible (counts differ by ≤1), then calculate swaps needed for both patterns and return the minimum. This greedy strategy runs in O(n²) time, much faster than the O(n!) brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Pattern Matching (Optimal)	O(n²)	O(n)	Try both possible patterns and choose the one requiring fewer swaps
Brute Force (Generate All Arrangements)	O(n! × n²)	O(n!)	Generate all possible arrangements and find the valid one with minimum swaps

Greedy Pattern Matching (Optimal) — Algorithm Steps

Separate the array into even and odd numbers
Check if alternating arrangement is possible (counts differ by at most 1)
Try pattern 1: place odds at even indices, evens at odd indices
Try pattern 2: place evens at even indices, odds at odd indices
For each pattern, count swaps needed using greedy placement
Return minimum swaps between the two patterns

Visualization

Tap to expand

Step-by-Step Walkthrough

Separate Even/Odd

Split the input into even and odd numbers

Check Feasibility

Verify counts differ by at most 1

Try Pattern 1

Calculate swaps for even-odd-even-odd pattern

Try Pattern 2

Calculate swaps for odd-even-odd-even pattern

Return Minimum

Choose the pattern requiring fewer swaps

Code -

solution.c — C

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

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

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

int countSwapsForPattern(int* nums, int n, int* evens, int evenCount, 
                        int* odds, int oddCount, int firstType) {
    int* target = (int*)malloc(n * sizeof(int));
    int evenIdx = 0, oddIdx = 0;
    
    for (int i = 0; i < n; i++) {
        if ((i % 2) == firstType) {
            if (firstType == 0) {
                if (evenIdx < evenCount) {
                    target[i] = evens[evenIdx++];
                } else {
                    free(target);
                    return INT_MAX;
                }
            } else {
                if (oddIdx < oddCount) {
                    target[i] = odds[oddIdx++];
                } else {
                    free(target);
                    return INT_MAX;
                }
            }
        } else {
            if (firstType == 0) {
                if (oddIdx < oddCount) {
                    target[i] = odds[oddIdx++];
                } else {
                    free(target);
                    return INT_MAX;
                }
            } else {
                if (evenIdx < evenCount) {
                    target[i] = evens[evenIdx++];
                } else {
                    free(target);
                    return INT_MAX;
                }
            }
        }
    }
    
    int* arr = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        arr[i] = nums[i];
    }
    
    int swaps = 0;
    for (int i = 0; i < n; i++) {
        if (arr[i] != target[i]) {
            for (int j = i + 1; j < n; j++) {
                if (arr[j] == target[i]) {
                    while (j > i) {
                        int temp = arr[j];
                        arr[j] = arr[j-1];
                        arr[j-1] = temp;
                        swaps++;
                        j--;
                    }
                    break;
                }
            }
        }
    }
    
    free(target);
    free(arr);
    return swaps;
}

int minSwaps(int* nums, int numsSize) {
    int* evens = (int*)malloc(numsSize * sizeof(int));
    int* odds = (int*)malloc(numsSize * sizeof(int));
    int evenCount = 0, oddCount = 0;
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] % 2 == 0) {
            evens[evenCount++] = nums[i];
        } else {
            odds[oddCount++] = nums[i];
        }
    }
    
    if (abs_val(evenCount - oddCount) > 1) {
        free(evens);
        free(odds);
        return -1;
    }
    
    int swaps1 = countSwapsForPattern(nums, numsSize, evens, evenCount, odds, oddCount, 0);
    int swaps2 = countSwapsForPattern(nums, numsSize, evens, evenCount, odds, oddCount, 1);
    
    int result = min_val(swaps1, swaps2);
    
    free(evens);
    free(odds);
    
    return result == INT_MAX ? -1 : result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) to separate numbers, O(n²) to count swaps for each pattern

⚠ Quadratic Growth

Space Complexity

O(n)

Extra space to store separated even and odd numbers

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~18 min Avg. Time

890 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 Pattern Matching (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler