Minimum Adjacent Swaps to Make a Valid Array

Minimum Adjacent Swaps to Make a Valid Array - Problem

Array Greedy Medium

You are given a 0-indexed integer array nums. Swaps of adjacent elements are able to be performed on nums.

A valid array meets the following conditions:

The largest element (any of the largest elements if there are multiple) is at the rightmost position in the array.
The smallest element (any of the smallest elements if there are multiple) is at the leftmost position in the array.

Return the minimum swaps required to make nums a valid array.

Input & Output

Example 1 — Basic Case

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

› Output: 5

💡 Note: Min element is 2 at index 4, needs 4 swaps to reach index 0. Max element is 5 at index 3 (rightmost occurrence), needs 1 swap to reach index 4. Since min is to the right of max, they cross during swapping, saving 1 swap. Total: 4+1-1=4 swaps.

Example 2 — Elements Cross

$ Input: nums = [9]

› Output: 0

💡 Note: Single element array is already valid, no swaps needed.

Example 3 — Min Right of Max

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

› Output: 3

💡 Note: Min(1) at index 2 needs 2 swaps left. Max(4) at index 1 needs 2 swaps right. They cross, so total: 2+2-1=3 swaps.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

M Microsoft 25 G Google 20 a Amazon 15

The key insight is to calculate exact distances without simulation. Find the leftmost minimum and rightmost maximum positions, calculate swaps needed for each to reach target positions, and subtract 1 if they cross paths during movement. Best approach uses direct calculation in O(n) time, O(1) space.

Common Approaches

✓ Brute Force Simulation

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

Keep performing adjacent swaps until the smallest element reaches position 0 and largest element reaches the last position. This simulates the actual swapping process.

Direct Position Calculation

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

Find positions of min and max elements, then calculate how many swaps each needs to reach its target position. Handle the special case when they cross paths.

Brute Force Simulation — Algorithm Steps

Find positions of minimum and maximum elements
Simulate swaps to move min to start
Simulate swaps to move max to end
Count total swaps performed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Find min and max elements in array

Move Min Left

Swap minimum element towards position 0

Move Max Right

Swap maximum element towards last position

Code -

solution.c — C

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

int solution(int* nums, int n) {
    if (n <= 1) {
        return 0;
    }
    
    int min_val = nums[0], max_val = nums[0];
    for (int i = 1; i < n; i++) {
        if (nums[i] < min_val) min_val = nums[i];
        if (nums[i] > max_val) max_val = nums[i];
    }
    
    // Find leftmost occurrence of minimum
    int min_pos = -1;
    for (int i = 0; i < n; i++) {
        if (nums[i] == min_val) {
            min_pos = i;
            break;
        }
    }
    
    // Find rightmost occurrence of maximum
    int max_pos = -1;
    for (int i = n-1; i >= 0; i--) {
        if (nums[i] == max_val) {
            max_pos = i;
            break;
        }
    }
    
    // Calculate swaps needed
    int swaps_for_min = min_pos;  // swaps to move min to position 0
    int swaps_for_max = (n - 1) - max_pos;  // swaps to move max to position n-1
    
    int total_swaps = swaps_for_min + swaps_for_max;
    
    // If min is to the right of max, they will cross and we save 1 swap
    if (min_pos > max_pos) {
        total_swaps -= 1;
    }
    
    return total_swaps;
}

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 main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int n;
    parseArray(line, nums, &n);
    
    printf("%d\n", solution(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each element might need O(n) swaps and we process up to n elements

⚠ Quadratic Growth

Space Complexity

O(1)

Only uses constant extra variables for tracking positions

✓ Linear Space

23.5K Views

Medium Frequency

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

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler