Minimum Number of Operations to Make Array Empty

Minimum Number of Operations to Make Array Empty - Problem

Problem Overview: You have an array of positive integers and need to completely empty it using two types of operations:

• Operation 1: Remove any 2 elements with the same value
• Operation 2: Remove any 3 elements with the same value

Your goal is to find the minimum number of operations needed to make the array empty. If it's impossible to empty the array, return -1.

For example, with array [2,3,3,2,2,4,2,3,4], you have:
• Four 2's → can be removed as 3+1 (2 operations)
• Three 3's → can be removed as 3 (1 operation)
• Two 4's → can be removed as 2 (1 operation)

Total: 4 operations to empty the array.

Input & Output

example_1.py — Basic case

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

› Output: 4

💡 Note: We have: 4 twos (can remove as 2+2: 2 operations), 3 threes (can remove as 3: 1 operation), 2 fours (can remove as 2: 1 operation). Total: 4 operations.

example_2.py — Impossible case

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

› Output: -1

💡 Note: Element 1 appears only once. Since we can only remove 2 or 3 identical elements at a time, it's impossible to remove the single 1.

example_3.py — Edge case with remainder 1

$ Input: [2,2,2,2,2]

› Output: 2

💡 Note: We have 5 twos. Optimal strategy is to remove 2+2=4 elements (2 operations) rather than 3+1+1 which would be impossible. Formula: (5+2)÷3 = 2.

Constraints

2 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
All elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Count Slice Types

First, count how many slices of each type you have

Apply Strategy

For each type, calculate minimum trips using the formula (count + 2) ÷ 3

Handle Edge Cases

If any slice type has only 1 slice, cleanup is impossible

Key Takeaway

🎯 Key Insight: The formula (count + 2) ÷ 3 automatically handles the optimal strategy: use groups of 3 when possible, but when remainder is 1, it's better to use two groups of 2 rather than leaving a single unusable item.

Asked in

G Google 45 a Amazon 38 f Meta 25 ⊞ Microsoft 22

The optimal solution uses a hash map to count frequencies and applies the mathematical insight that for count n, the minimum operations is (n + 2) ÷ 3. This formula elegantly handles all cases: when remainder is 1, it optimally uses groups of 2 instead of leaving unusable single elements.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table with Math	O(n)	O(n)	Count frequencies first, then apply mathematical formula for each count
Brute Force (Try All Combinations)	O(n + f²)	O(n)	For each unique element, try all possible combinations of operations
One-Pass Hash Table (Optimal)	O(n)	O(k)	Count frequencies and calculate operations simultaneously in single pass

Two-Pass Hash Table with Math — Algorithm Steps

First pass: Build frequency map of all elements
Second pass: For each frequency, apply mathematical insight
For count n: if n%3 == 1, we need (n-4)/3 + 2 operations; otherwise ceiling(n/3)
Return -1 if any element appears exactly once

Visualization

Tap to expand

Step-by-Step Walkthrough

First Pass - Count

Build frequency map of all elements

Second Pass - Calculate

Apply mathematical formula to each frequency

Code -

solution.c — C

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

int minOperations(int* nums, int numsSize) {
    // First pass: count frequencies
    int freq[100001] = {0};
    for (int i = 0; i < numsSize; i++) {
        freq[nums[i]]++;
    }
    
    int totalOps = 0;
    
    // Second pass: calculate optimal operations
    for (int i = 1; i <= 100000; i++) {
        if (freq[i] == 0) continue;
        
        int count = freq[i];
        if (count == 1) {
            return -1;
        }
        
        if (count % 3 == 0) {
            totalOps += count / 3;
        } else if (count % 3 == 1) {
            totalOps += (count - 4) / 3 + 2;
        } else {
            totalOps += count / 3 + 1;
        }
    }
    
    return totalOps;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) for first pass to count frequencies + O(k) for second pass where k is unique elements

✓ Linear Growth

Space Complexity

O(n)

Hash map to store frequency of each unique element

⚡ Linearithmic Space

32.5K Views

Medium-High Frequency

~18 min Avg. Time

1.2K 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

Two-Pass Hash Table with Math — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler