Minimum Array Length After Pair Removals - Practice Coding Problems

Minimum Array Length After Pair Removals - Problem

You're given a sorted integer array nums in non-decreasing order. Your goal is to strategically remove pairs of elements to minimize the final array length.

The Pairing Rule: You can only remove two elements nums[i] and nums[j] if nums[i] < nums[j] (strictly less than). Once removed, the remaining elements maintain their original relative order and the array gets re-indexed.

Think of it like a matching game - you want to pair up as many elements as possible, but smaller elements can only be paired with larger ones. The challenge is finding the optimal pairing strategy to leave the fewest elements unpaired.

Example: With array [1,1,2,2,3,3], you could pair (1,2), (1,2), (3,3) - but wait, you can't pair (3,3) since 3 is not less than 3! The optimal strategy gives you 2 remaining elements.

Input & Output

example_1.py — Basic Case

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

› Output: 0

💡 Note: We can pair (1,3) and (2,4) since 1 < 3 and 2 < 4. After removing both pairs, the array becomes empty, so the minimum length is 0.

example_2.py — Identical Elements

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

› Output: 2

💡 Note: We can pair (1,2), (1,2), but we cannot pair (3,3) since 3 is not less than 3. The remaining unpaired elements are [2,3], giving us a minimum length of 2.

example_3.py — All Identical

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

› Output: 4

💡 Note: No pairs can be formed since all elements are equal (2 is not less than 2). All 4 elements remain unpaired.

Visualization

Tap to expand

Understanding the Visualization

Guest Arrival

Guests arrive in height order [1,1,2,2,3,3]

Count Heights

Count how many guests of each height: 1→2, 2→2, 3→2

Find Bottleneck

No single height dominates (max freq = 2 ≤ n/2 = 3)

Perfect Pairing

All guests can be paired: (1,2), (1,2), (3,?) → remaining = 2

Mathematical Result

Formula gives: max(0, 2×2-6) = 2 unpaired guests

Key Takeaway

🎯 Key Insight: The most frequent element acts as a bottleneck - if it appears more than n/2 times, those excess elements will remain unpaired, determining the minimum length.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count frequencies, then one pass through frequency map

✓ Linear Growth

Space Complexity

O(n)

Hash map to store frequency of each unique element

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
nums is sorted in non-decreasing order

Asked in

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

The optimal solution uses frequency counting with the key insight that the most frequent element determines the minimum remaining length. The mathematical formula max(0, 2 × max_frequency - n) elegantly captures the pairing constraint in O(n) time and O(n) space.

Common Approaches

Approach	Time	Space	Notes
✓ Frequency Counting (Optimal)	O(n)	O(n)	Count frequencies and use mathematical insight: answer is 2×max_frequency - n
Brute Force Simulation	O(2^n)	O(n)	Try all possible pair removals recursively until no more pairs can be formed
Greedy Two Pointers	O(n)	O(1)	Use two pointers to greedily pair smaller elements with larger ones

Frequency Counting (Optimal) — Algorithm Steps

Count frequency of each element using hash map
Find the maximum frequency among all elements
Apply formula: min_length = max(0, 2 * max_frequency - n)
This works because the most frequent element limits pairing possibilities
If max_frequency ≤ n/2, all elements can be paired (answer is n % 2)

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Build frequency map of all elements

Find Maximum

Identify the most frequent element

Apply Formula

Calculate: max(0, 2×max_freq - n)

Understand Why

Most frequent element creates pairing bottleneck

Return Answer

Mathematical result gives optimal length

Code -

solution.c — C

int minLengthAfterRemovals(int* nums, int numsSize) {
    int n = numsSize;
    if (n <= 1) {
        return n;
    }
    
    // For sorted array, we can count frequencies more efficiently
    int maxFreq = 1;
    int currentFreq = 1;
    
    for (int i = 1; i < n; i++) {
        if (nums[i] == nums[i-1]) {
            currentFreq++;
        } else {
            if (currentFreq > maxFreq) {
                maxFreq = currentFreq;
            }
            currentFreq = 1;
        }
    }
    
    if (currentFreq > maxFreq) {
        maxFreq = currentFreq;
    }
    
    // Key insight: minimum length = max(0, 2 * max_freq - n)
    int result = 2 * maxFreq - n;
    return result > 0 ? result : 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count frequencies, then one pass through frequency map

✓ Linear Growth

Space Complexity

O(n)

Hash map to store frequency of each unique element

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
nums is sorted in non-decreasing order

23.2K Views

Medium Frequency

~15 min Avg. Time

847 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Frequency Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler