Minimum Number of Operations to Make Elements in Array Distinct

Minimum Number of Operations to Make Elements in Array Distinct - Problem

You are given an integer array nums that may contain duplicate elements. Your goal is to make all elements in the array distinct by performing a special removal operation.

In each operation, you can:

Remove exactly 3 elements from the beginning of the array
If the array has fewer than 3 elements remaining, remove all remaining elements

Note: An empty array is considered to have distinct elements.

Return the minimum number of operations needed to make all elements in the array distinct.

Example: If nums = [1, 2, 3, 1, 2], we have duplicates (1 and 2 appear twice). We need to remove elements from the front until no duplicates remain.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: We have duplicates: 1 appears at positions 0 and 3, 2 appears at positions 1 and 4. After 1 operation (removing first 3 elements), we have [1, 2] which still has the duplicates from the original array. After 2 operations (removing all elements), we have an empty array which is considered distinct.

example_2.py — Already Distinct

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

› Output: 0

💡 Note: All elements are already distinct, so no operations are needed.

example_3.py — Single Element

$ Input: [5]

› Output: 0

💡 Note: A single element array is always distinct, so 0 operations are needed.

Constraints

0 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
You can only remove elements from the beginning of the array
Each operation removes exactly 3 elements (or all remaining if < 3)

Visualization

Tap to expand

Understanding the Visualization

Identify the Goal

We need all remaining books to be unique (no duplicate titles)

Work Backwards

Instead of simulating removals, find the rightmost position where all books to the right are unique

Calculate Operations

Once we know how many books to remove from the left, divide by 3 (rounding up) to get operations needed

Key Takeaway

🎯 Key Insight: Work backwards to find the rightmost position where the suffix contains only distinct elements, then calculate the minimum operations needed to remove everything to the left of that position.

Asked in

G Google 25 a Amazon 20 f Meta 15 ⊞ Microsoft 12

The optimal approach works backwards from the end of the array to find the rightmost position where all elements to the right form a distinct sequence. This avoids redundant checking and solves the problem in O(n) time using a hash set to track seen elements.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Positions)	O(n²)	O(n)	Try removing elements from the beginning until we find a distinct suffix
Optimal: Rightmost Distinct Position	O(n)	O(n)	Find the rightmost position where all elements to the right are distinct

Brute Force (Try All Positions) — Algorithm Steps

For each possible number of operations (0 to ceil(n/3))
Calculate how many elements to remove (operations * 3, capped at array length)
Check if the remaining suffix has all distinct elements
Return the minimum operations needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with 0 operations

Check if original array has distinct elements

Try 1 operation

Remove first 3 elements, check if remainder is distinct

Continue until distinct

Keep removing 3 elements until no duplicates remain

Code -

solution.c — C

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

int minimumOperations(int* nums, int n) {
    // Try each possible number of operations
    for (int ops = 0; ops <= (n + 2) / 3; ops++) {
        // Calculate elements to remove
        int remove = (ops * 3 < n) ? ops * 3 : n;
        
        // Check if remaining elements are distinct (simple O(n²) check)
        int distinct = 1;
        for (int i = remove; i < n && distinct; i++) {
            for (int j = i + 1; j < n; j++) {
                if (nums[i] == nums[j]) {
                    distinct = 0;
                    break;
                }
            }
        }
        
        if (distinct) return ops;
    }
    
    return (n + 2) / 3;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    
    // Simple parsing
    scanf("%c", &c); // skip '['
    while (scanf("%d%c", &nums[n], &c) == 2) {
        n++;
        if (c == ']') break;
    }
    
    printf("%d\n", minimumOperations(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) operations to try × O(n) time to check distinctness

⚠ Quadratic Growth

Space Complexity

O(n)

Hash set to check distinctness for each attempt

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~15 min Avg. Time

856 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 (Try All Positions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler