Sort Array by Moving Items to Empty Space

Sort Array by Moving Items to Empty Space - Problem

You are given an integer array nums of size n containing each element from 0 to n - 1 (inclusive). Each of the elements from 1 to n - 1 represents an item, and the element 0 represents an empty space.

In one operation, you can move any item to the empty space.

nums is considered to be sorted if the numbers of all the items are in ascending order and the empty space is either at the beginning or at the end of the array.

For example, if n = 4, nums is sorted if:

nums = [0,1,2,3] or nums = [1,2,3,0]

...and considered to be unsorted otherwise.

Return the minimum number of operations needed to sort nums.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: Target [1,2,3,0]: positions 2 and 3 are correct (3 and 0). So 4-2=2 moves needed.

Example 2 — Already Sorted

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

› Output: 0

💡 Note: Array is already in sorted form [0,1,2,3], so no moves needed.

Example 3 — Alternative Sort

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

› Output: 0

💡 Note: Array is already in alternative sorted form [1,2,3,0], so no moves needed.

Constraints

2 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] < nums.length
All the values of nums are unique.

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is recognizing there are exactly two valid sorted configurations: [0,1,2,3,...] or [1,2,3,...,0]. Count elements already in correct positions for both targets and choose the configuration requiring fewer moves. Best approach uses greedy counting in O(n) time.

Common Approaches

✓ Brute Force BFS

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

Generate all possible states by moving items to empty space, use BFS to find shortest path to sorted state. This explores every possible combination of moves.

Greedy Cycle Detection

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

The key insight is that we have two possible target configurations. For each target, count how many elements are already in correct positions. The answer is n minus the maximum count of correct positions.

Brute Force BFS — Algorithm Steps

Start with initial array state
Generate all possible moves (swap any item with 0)
Use BFS to find minimum moves to reach sorted state

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with given array configuration

Generate Moves

Try swapping 0 with each other element

BFS Search

Use queue to find minimum moves to sorted state

Code -

solution.c — C

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

#define MAX_STATES 100000
#define HASH_SIZE 50000

static int queue_arr[MAX_STATES][10];
static int queue_moves[MAX_STATES];

typedef struct HashNode {
    unsigned long long hash;
    struct HashNode* next;
} HashNode;

static HashNode* hashTable[HASH_SIZE];
static HashNode nodePool[MAX_STATES];
static int nodePoolIndex = 0;

unsigned long long hashArray(int* arr, int n) {
    unsigned long long hash = 0;
    for (int i = 0; i < n; i++) {
        hash = hash * 31 + arr[i];
    }
    return hash;
}

int isVisited(int* arr, int n) {
    unsigned long long hash = hashArray(arr, n);
    int index = hash % HASH_SIZE;
    
    HashNode* node = hashTable[index];
    while (node) {
        if (node->hash == hash) return 1;
        node = node->next;
    }
    return 0;
}

void markVisited(int* arr, int n) {
    unsigned long long hash = hashArray(arr, n);
    int index = hash % HASH_SIZE;
    
    if (nodePoolIndex < MAX_STATES) {
        HashNode* newNode = &nodePool[nodePoolIndex++];
        newNode->hash = hash;
        newNode->next = hashTable[index];
        hashTable[index] = newNode;
    }
}

int arraysEqual(int* a, int* b, int n) {
    for (int i = 0; i < n; i++) {
        if (a[i] != b[i]) return 0;
    }
    return 1;
}

int solution(int* nums, int n) {
    int target1[10], target2[10];
    
    // Initialize hash table
    for (int i = 0; i < HASH_SIZE; i++) {
        hashTable[i] = NULL;
    }
    nodePoolIndex = 0;
    
    // Target 1: [0, 1, 2, ..., n-1]
    // Target 2: [1, 2, 3, ..., n-1, 0]
    for (int i = 0; i < n; i++) {
        target1[i] = i;
        target2[i] = (i == n - 1) ? 0 : i + 1;
    }
    
    // Check if already at target
    if (arraysEqual(nums, target1, n) || arraysEqual(nums, target2, n)) {
        return 0;
    }
    
    int front = 0, rear = 1;
    
    // Initialize queue with starting state
    for (int i = 0; i < n; i++) {
        queue_arr[0][i] = nums[i];
    }
    queue_moves[0] = 0;
    
    markVisited(nums, n);
    
    // BFS
    while (front < rear && rear < MAX_STATES) {
        int* current = queue_arr[front];
        int moves = queue_moves[front];
        front++;
        
        // Find position of 0 (empty space)
        int zeroPos = -1;
        for (int i = 0; i < n; i++) {
            if (current[i] == 0) {
                zeroPos = i;
                break;
            }
        }
        
        // Try swapping each element with the empty space
        for (int i = 0; i < n; i++) {
            if (i == zeroPos) continue;
            
            // Create new state
            for (int j = 0; j < n; j++) {
                queue_arr[rear][j] = current[j];
            }
            
            // Swap: exchange item at position i with empty space at zeroPos
            int temp = queue_arr[rear][i];
            queue_arr[rear][i] = queue_arr[rear][zeroPos];
            queue_arr[rear][zeroPos] = temp;
            
            // Check if reached target
            if (arraysEqual(queue_arr[rear], target1, n) || 
                arraysEqual(queue_arr[rear], target2, n)) {
                return moves + 1;
            }
            
            // Add to queue if not visited
            if (!isVisited(queue_arr[rear], n)) {
                queue_moves[rear] = moves + 1;
                markVisited(queue_arr[rear], n);
                rear++;
            }
        }
    }
    
    return -1; // No solution found
}

int main() {
    char line[10000];
    
    if (fgets(line, sizeof(line), stdin) == NULL) {
        printf("-1\n");
        return 0;
    }
    
    // Remove newline
    line[strcspn(line, "\n")] = 0;
    line[strcspn(line, "\r")] = 0;
    
    // Parse array [1, 2, 0, 3, ...]
    int nums[10];
    int n = 0;
    
    char* p = line;
    
    // Find opening '['
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse numbers
    while (*p && *p != ']' && n < 10) {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        
        if (*p == ']' || *p == '\0') break;
        
        // Parse number (handle negative)
        char* endPtr;
        long num = strtol(p, &endPtr, 10);
        
        if (endPtr != p) {
            nums[n++] = (int)num;
            p = endPtr;
        } else {
            p++;
        }
    }
    
    if (n == 0) {
        printf("0\n");
        return 0;
    }
    
    int result = solution(nums, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! possible permutations, each requiring O(n) time to process

✓ Linear Growth

Space Complexity

O(n! × n)

Queue stores up to n! states, each state is array of size n

✓ Linear Space

23.4K Views

Medium Frequency

~25 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 BFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler