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. You need to ensure that the elements in the array are distinct.

To achieve this, you can perform the following operation any number of times:

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

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

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

Input & Output

Example 1 — Duplicate Elements

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

› Output: 1

💡 Note: Elements 1 appears twice. Remove first 3 elements [1,2,1], leaving [3,4] which are distinct. One operation needed.

Example 2 — Already Distinct

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

› Output: 0

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

Example 3 — Small Array with Duplicates

$ Input: nums = [1,1]

› Output: 1

💡 Note: Two duplicate 1s. Since array has less than 3 elements, remove all in one operation.

Constraints

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

Visualization

Tap to expand

Asked in

f Meta 8 G Google 6 a Amazon 4

The key insight is to work backwards from the end of the array to find the rightmost position where all elements to the right are distinct. The optimal approach uses a hash map in O(n) time to scan right-to-left, stopping at the first duplicate found. Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force Simulation

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

Keep removing 3 elements from the beginning and check if remaining elements are all distinct. Continue until we achieve a distinct array.

Hash Map Optimization

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

Work backwards from the end, using a hash map to track seen elements. Find the rightmost position where we can start with all distinct elements.

Brute Force Simulation — Algorithm Steps

Step 1: Check if current array has all distinct elements
Step 2: If not, remove first 3 elements (or all if less than 3)
Step 3: Increment operation count and repeat

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Array

Look for duplicate elements

Remove Elements

Take 3 from front if duplicates exist

Repeat

Continue until all elements distinct

Code -

solution.c — C

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

static int nums[100005];
static bool seen[2000005];

int solution(int size) {
    int operations = 0;
    int start = 0;
    
    while (start < size) {
        // Clear seen array
        memset(seen, false, sizeof(seen));
        
        // Check if remaining elements are distinct
        bool isDistinct = true;
        
        for (int i = start; i < size; i++) {
            int val = nums[i] + 1000000; // Offset for negative numbers
            if (seen[val]) {
                isDistinct = false;
                break;
            }
            seen[val] = true;
        }
        
        if (isDistinct) {
            break;
        }
        
        // Remove 3 elements from beginning (or all remaining)
        if (size - start <= 3) {
            start = size;
        } else {
            start += 3;
        }
        operations++;
    }
    
    return operations;
}

int main() {
    char line[500005];
    fgets(line, sizeof(line), stdin);
    
    int size = 0;
    char* p = line;
    
    // Skip opening bracket
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse numbers
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        long val = strtol(p, &p, 10);
        nums[size++] = (int)val;
    }
    
    printf("%d\n", solution(size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n/3 operations, we check all remaining elements for duplicates

⚠ Quadratic Growth

Space Complexity

O(n)

Hash set to check for duplicates in remaining array

⚡ Linearithmic Space

12.4K Views

Medium Frequency

~15 min Avg. Time

245 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler