Minimum Increment to Make Array Unique - Practice Coding Problems

Minimum Increment to Make Array Unique - Problem

Minimum Increment to Make Array Unique

You are given an integer array nums that may contain duplicate values. Your goal is to make every element in the array unique by performing a series of increment operations.

In each operation, you can pick any index i where 0 <= i < nums.length and increment nums[i] by 1. You need to find the minimum number of moves required to make all values unique.

Example: If you have [3, 3, 3], you could transform it to [3, 4, 5] using 3 moves (0 + 1 + 2).

Note: You can only increment values (never decrement), and the test cases guarantee the answer fits in a 32-bit integer.

Input & Output

example_1.py — Basic duplicate removal

$ Input: [1, 2, 2]

› Output: 1

💡 Note: After sorting: [1, 2, 2]. The second 2 needs to be incremented to 3, requiring 1 move. Final array: [1, 2, 3]

example_2.py — Multiple duplicates

$ Input: [3, 3, 3]

› Output: 3

💡 Note: After sorting: [3, 3, 3]. Second 3 becomes 4 (1 move), third 3 becomes 5 (2 moves). Total: 1 + 2 = 3 moves. Final array: [3, 4, 5]

example_3.py — Already unique

$ Input: [1, 3, 5, 7]

› Output: 0

💡 Note: All elements are already unique, so no moves are needed. The array remains [1, 3, 5, 7]

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁵
Important: You can only increment values, never decrement them

Visualization

Tap to expand

Understanding the Visualization

Sort Tickets

First, sort all ticket holders by their current seat numbers to process them systematically

Process in Order

Go through each person in order. If their seat is taken, assign them to the next available higher seat

Count Moves

Each seat reassignment counts as moves equal to the difference from original to new seat

Key Takeaway

🎯 Key Insight: Sorting first allows us to process duplicates in order, ensuring we always assign the smallest possible higher number to each duplicate, minimizing total moves.

Asked in

G Google 45 a Amazon 32 ⊞ Microsoft 28 Apple 15

The optimal solution uses a greedy approach after sorting: sort the array first, then iterate through it. When we find a duplicate or a value smaller than the previous assigned value, we increment it to the next available value (previous + 1). This ensures minimal moves with O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Each Position)	O(n²)	O(n)	For each duplicate, linearly search for the next available unique value
Sorting + Greedy (Optimal)	O(n log n)	O(1)	Sort array first, then process duplicates greedily by assigning next available value

Brute Force (Check Each Position) — Algorithm Steps

Create a set to track used values
For each element in the array, if it's already used, keep incrementing until we find an unused value
Add the final value to our used set and count the moves
Return total moves

Visualization

Tap to expand

Step-by-Step Walkthrough

Process First Element

Check if 3 is used, if not add to used set

Process Second Element

Check if 3 is used (yes), increment to 4, check if 4 is used (no), add 4 to used set

Process Third Element

Check if 3 is used (yes), increment to 4, check if 4 is used (yes), increment to 5, add 5 to used set

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define MAX_VAL 100000

int minIncrementForUnique(int* nums, int numsSize) {
    bool used[MAX_VAL * 2] = {false};
    int moves = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int current = nums[i];
        while (current < MAX_VAL * 2 && used[current]) {
            current++;
            moves++;
        }
        if (current < MAX_VAL * 2) {
            used[current] = true;
        }
    }
    
    return moves;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    int nums[1000], size = 0;
    char* token = strtok(input + 1, ",]");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    printf("%d\n", minIncrementForUnique(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each element, we might need to check many positions to find an unused value, leading to quadratic time in worst case

⚠ Quadratic Growth

Space Complexity

O(n)

We need a set to track all used values

⚡ Linearithmic Space

24.6K Views

Medium Frequency

~15 min Avg. Time

892 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 (Check Each Position) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler