Sorting Three Groups - Practice Coding Problems

Sorting Three Groups - Problem

You are given an integer array nums where each element is exactly 1, 2, or 3. Your goal is to make the array non-decreasing (sorted in ascending order) by performing the minimum number of removal operations.

In each operation, you can remove any element from the array. The challenge is to find the minimum number of elements to remove so that the remaining elements form a non-decreasing sequence.

Example: If nums = [2,1,3,2,1], you could remove the elements at indices 1 and 4 (both 1's) to get [2,3,2], then remove one more 2 to get [2,3] which is non-decreasing. The answer would be 3 operations.

Key insight: This is equivalent to finding the longest non-decreasing subsequence and subtracting its length from the total array length!

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: One optimal solution is to remove elements at indices 1 and 4 (both 1's) and the element at index 3 (one of the 2's), leaving [2,3] which is non-decreasing. We need 3 operations total.

example_2.py — Already Sorted

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

› Output: 0

💡 Note: The array is already non-decreasing, so no operations are needed. The minimum number of operations is 0.

example_3.py — Reverse Sorted

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

› Output: 3

💡 Note: We can keep [3,3] (removing 2,1,1) or keep [2] (removing 3,3,1,1) or keep [1,1] (removing 3,3,2). The longest non-decreasing subsequence has length 2, so we need 5-2=3 operations.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 3
Each element is guaranteed to be 1, 2, or 3

Visualization

Tap to expand

Understanding the Visualization

Initial Shelf

Books are randomly arranged: [Intermediate, Beginner, Advanced, Intermediate, Beginner]

Track Best Sequences

For each difficulty level, track the longest valid sequence ending at that level

Update Optimally

When placing a book, extend the best possible sequence from equal or lower difficulties

Calculate Removals

Remove minimum books = Total books - Longest valid sequence

Key Takeaway

🎯 Key Insight: Since we only have 3 possible values, we can efficiently track the optimal subsequence ending at each value in O(n) time rather than using the traditional O(n²) LIS approach!

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal approach leverages the constraint that elements are only 1, 2, or 3. We track the longest non-decreasing subsequence ending with each value using dynamic programming in O(n) time. The answer is n minus the length of the longest such subsequence.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Subsequences)	O(n * 2^n)	O(n)	Generate all possible subsequences and find the longest non-decreasing one
Dynamic Programming - Classic LIS	O(n²)	O(n)	Use classic dynamic programming approach to find longest non-decreasing subsequence
Optimized DP with Three Values	O(n)	O(1)	Leverage the constraint that values are only 1, 2, or 3 for O(n) solution

Brute Force (Generate All Subsequences) — Algorithm Steps

Generate all possible subsequences using bit manipulation
For each subsequence, check if it's non-decreasing
Keep track of the maximum length non-decreasing subsequence
Return n - max_length

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Mask

Create binary mask to represent which elements to include

Build Subsequence

Extract elements based on mask bits

Validate Order

Check if subsequence is non-decreasing

Track Maximum

Update longest valid subsequence found

Code -

solution.c — C

int minimumOperations(int* nums, int numsSize) {
    int maxLength = 0;
    
    // Try all possible subsequences using bit manipulation
    for (int mask = 0; mask < (1 << numsSize); mask++) {
        int subsequence[2000];
        int subLen = 0;
        
        for (int i = 0; i < numsSize; i++) {
            if (mask & (1 << i)) {
                subsequence[subLen++] = nums[i];
            }
        }
        
        // Check if subsequence is non-decreasing
        int isValid = 1;
        for (int i = 1; i < subLen; i++) {
            if (subsequence[i] < subsequence[i-1]) {
                isValid = 0;
                break;
            }
        }
        
        if (isValid && subLen > maxLength) {
            maxLength = subLen;
        }
    }
    
    return numsSize - maxLength;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * 2^n)

We generate 2^n subsequences and check each one in O(n) time

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current subsequence and recursion stack

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~12 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 (Generate All Subsequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler