Make Array Empty

Make Array Empty - Problem

Array Binary Search Greedy Binary Indexed Tree Segment Tree Sorting Ordered Set Hard

You are given an integer array nums containing distinct numbers, and you can perform the following operations until the array is empty:

If the first element has the smallest value, remove it
Otherwise, put the first element at the end of the array

Return an integer denoting the number of operations it takes to make nums empty.

Input & Output

Example 1 — Basic Case

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

› Output: 7

💡 Note: Operations: [3,1,4,2]→[1,4,2,3]→[4,2,3]→[2,3,4]→[3,4]→[4,3]→[4]→[]. Total: 7 operations.

Example 2 — Already Sorted

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

› Output: 3

💡 Note: Elements are already in ascending order, so each can be removed immediately: 1+1+1 = 3 operations.

Example 3 — Reverse Order

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

› Output: 10

💡 Note: Worst case: need to rotate many times. Remove 1 (pos 3): 4 ops. Remove 2 (pos 2): 3 ops. Remove 3 (pos 1): 2 ops. Remove 4 (pos 0): 1 op. Total: 10.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
All elements in nums are distinct

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 f Meta 8

The key insight is that elements must be removed in ascending order, so we can calculate operations mathematically. The optimal approach sorts the array with indices and computes the position adjustments. Time: O(n log n), Space: O(n)

Common Approaches

✓ Mathematical Formula

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

Use mathematical insight: for each element, calculate operations needed based on its current position relative to elements that must be removed first.

Simulation

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

Directly simulate the operations by checking if the first element is the minimum, removing it if true, otherwise moving it to the end.

Sort-Based Solution

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

Sort the array to know the order elements will be removed, then for each element calculate how many rotations are needed to bring it to the front.

Mathematical Formula — Algorithm Steps

Sort array with original indices
For each element, count how many smaller elements come after it
Use formula: position + count of smaller elements after
Sum all operations

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Pairs

Store (value, original_index) pairs

Sort by Value

Sort to get removal order

Calculate Formula

For each element: current_position + 1

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int solution(int* nums, int size) {
    int* sorted_nums = (int*)malloc(size * sizeof(int));
    for (int i = 0; i < size; i++) {
        sorted_nums[i] = nums[i];
    }
    qsort(sorted_nums, size, sizeof(int), compare);
    
    int operations = 0;
    int remaining = size;
    
    for (int i = 0; i < size; i++) {
        int target = sorted_nums[i];
        int pos = -1;
        
        for (int j = 0; j < remaining; j++) {
            if (nums[j] == target) {
                pos = j;
                break;
            }
        }
        
        operations += pos + 1;
        
        // Remove element by shifting
        for (int j = pos; j < remaining - 1; j++) {
            nums[j] = nums[j + 1];
        }
        remaining--;
    }
    
    free(sorted_nums);
    return operations;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int size = 0;
    
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", solution(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(n log n), then single pass to calculate operations

⚠ Quadratic Growth

Space Complexity

O(n)

Extra space for storing value-index pairs

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~25 min Avg. Time

234 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

Mathematical Formula — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler