Minimum Number of Operations to Make Array Empty

Minimum Number of Operations to Make Array Empty - Problem

You are given a 0-indexed array nums consisting of positive integers.

There are two types of operations that you can apply on the array any number of times:

Choose two elements with equal values and delete them from the array.
Choose three elements with equal values and delete them from the array.

Return the minimum number of operations required to make the array empty, or -1 if it is not possible.

Input & Output

Example 1 — Mixed Frequencies

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

› Output: -1

💡 Note: Element 1 appears only once, which cannot be removed using operations that require 2 or 3 identical elements. Therefore, it's impossible to make the array empty.

Example 2 — All Removable

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

› Output: 3

💡 Note: Element 2 appears 3 times → ceil(3/3)=1 operation, element 3 appears 2 times → ceil(2/3)=1 operation, element 4 appears 3 times → ceil(3/3)=1 operation. Total: 3 operations.

Example 3 — Large Frequencies

$ Input: nums = [14,12,14,14,12,14,14,12,12,12,12,14,14,12,14,14,14,12]

› Output: 6

💡 Note: Element 12 appears 9 times → ceil(9/3)=3 operations. Element 14 appears 9 times → ceil(9/3)=3 operations. Total = 6 operations.

Constraints

2 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that we can only remove elements in groups of 2 or 3, so any element appearing only once makes the problem impossible. For elements with frequency f ≥ 2, the minimum operations needed is ceil(f/3), which greedily uses as many groups of 3 as possible. Best approach is Greedy Mathematical with Time: O(n), Space: O(k).

Common Approaches

✓ Frequency Count with Math

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

Count frequency of each element, then for each frequency f: if f=1 return -1, else return ceil(f/3) operations (greedy approach using as many 3s as possible).

Greedy Mathematical Approach

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

For each element frequency, greedily use as many groups of 3 as possible, then groups of 2. The formula ceil(count/3) gives the minimum operations needed.

Recursive Enumeration

⏱️ Time: O(3^n) Space: O(n)

For each unique element, recursively try all valid combinations of removing 2s and 3s until we find the minimum operations needed.

Frequency Count with Math — Algorithm Steps

Count frequency of each element
For each frequency, calculate minimum operations using ceil(f/3)
Sum all operations

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Count occurrences of each unique element

Apply Formula

For each frequency f: operations = ceil(f/3)

Sum Operations

Add up all operations needed

Code -

solution.c — C

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

#define MAX_SIZE 100000

typedef struct {
    int key;
    int value;
} Pair;

int solution(int* nums, int numsSize) {
    Pair freq[MAX_SIZE];
    int freqSize = 0;
    
    // Count frequencies
    for (int i = 0; i < numsSize; i++) {
        int found = 0;
        for (int j = 0; j < freqSize; j++) {
            if (freq[j].key == nums[i]) {
                freq[j].value++;
                found = 1;
                break;
            }
        }
        if (!found) {
            freq[freqSize].key = nums[i];
            freq[freqSize].value = 1;
            freqSize++;
        }
    }
    
    int totalOps = 0;
    for (int i = 0; i < freqSize; i++) {
        int count = freq[i].value;
        if (count == 1) {
            return -1; // Cannot remove single element
        }
        // Use ceil(count / 3) operations
        // Equivalent to (count + 2) / 3 in integer division
        totalOps += (count + 2) / 3;
    }
    
    return totalOps;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count frequencies, then O(unique elements) to calculate operations

✓ Linear Growth

Space Complexity

O(n)

Hash map stores frequency of each unique element

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

890 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

Frequency Count with Math — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler