Make Array Empty - Practice Coding Problems

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. Your goal is to completely empty the array using a specific set of operations.

Operations allowed:

If the first element has the smallest value in the entire array, remove it
Otherwise, move the first element to the end of the array

Return the total number of operations needed to make the array empty.

Example: For array [3, 4, 1, 2]:

First element is 3 (not smallest), move to end → [4, 1, 2, 3]
First element is 4 (not smallest), move to end → [1, 2, 3, 4]
First element is 1 (smallest), remove → [2, 3, 4]
Continue until empty...

This problem tests your understanding of array manipulation, sorting concepts, and optimization techniques.

Input & Output

example_1.py — Basic Case

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

› Output: 8

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

example_2.py — Already Sorted

$ Input: [1, 2, 3, 4, 5]

› Output: 5

💡 Note: Array is already sorted, so we can remove each element immediately without any rotations. Each removal takes 1 operation, total: 5 operations

example_3.py — Reverse Sorted

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

› Output: 10

💡 Note: Worst case where smallest element is at the end. Need maximum rotations: 3 rotations + 1 removal for element 1, then continue with remaining elements

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
All elements in nums are distinct
The array contains at least one element

Visualization

Tap to expand

Understanding the Visualization

Initial Queue

People with tickets [3, 4, 1, 2] line up

Check Priority

Person with ticket 3 is first, but person with ticket 1 has priority

Cycle Queue

Person with ticket 3 goes to back, then person with ticket 4

Serve Customer

Person with ticket 1 is now first and gets served

Repeat Process

Continue until everyone is served

Key Takeaway

🎯 Key Insight: Instead of simulating the actual queue movements, we can mathematically calculate the total operations by determining the removal order (via sorting) and computing how many rotations each element needs based on its position relative to previously removed elements.

Asked in

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

The optimal approach uses position tracking instead of array simulation. First, sort the array to determine removal order, then calculate operations by tracking how positions change after each removal. This avoids expensive array operations while maintaining O(n²) time complexity with O(n) space.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized with Sorting and Position Tracking	O(n²)	O(n)	Pre-sort to determine removal order, then calculate rotations needed
Brute Force Simulation	O(n³)	O(1)	Simulate the exact process described in the problem

Optimized with Sorting and Position Tracking — Algorithm Steps

Create a mapping of value to original index
Sort the values to get removal order
For each value in sorted order, find its current position
Calculate operations needed: rotations + 1 removal
Update positions after each removal

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Values

Determine removal order: [1, 2, 3, 4]

Track Positions

Map each value to its current position

Calculate Rotations

For each removal, count needed rotations

Update Positions

Adjust positions after each removal

Code -

solution.c — C

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

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

long long solution(int* nums, int size) {
    // Create position mapping
    int* values = (int*)malloc(size * sizeof(int));
    int* positions = (int*)malloc(size * sizeof(int));
    
    for (int i = 0; i < size; i++) {
        values[i] = nums[i];
        positions[i] = i;
    }
    
    // Sort values
    qsort(values, size, sizeof(int), compare);
    
    long long operations = 0;
    int currentPos = 0;
    int currentSize = size;
    
    for (int i = 0; i < size; i++) {
        int val = values[i];
        int valPos = -1;
        
        // Find position of val
        for (int j = 0; j < size; j++) {
            if (nums[j] == val) {
                valPos = positions[j];
                break;
            }
        }
        
        int rotations;
        if (valPos >= currentPos) {
            rotations = valPos - currentPos;
        } else {
            rotations = (currentSize - currentPos) + valPos;
        }
        
        operations += rotations + 1;
        
        // Update positions
        for (int j = 0; j < size; j++) {
            if (positions[j] > valPos) {
                positions[j]--;
            }
        }
        
        currentSize--;
        currentPos = valPos < currentSize ? valPos : 0;
    }
    
    free(values);
    free(positions);
    return operations;
}

int main() {
    int nums[] = {3, 4, 1, 2};
    printf("%lld\n", solution(nums, 4));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n log n) for sorting + O(n²) for position calculations

⚠ Quadratic Growth

Space Complexity

O(n)

Space for mapping values to positions and sorted array

⚡ Linearithmic Space

28.9K Views

Medium-High Frequency

~25 min Avg. Time

850 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

Optimized with Sorting and Position Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler