Minimum Increment operations to make Array unique

Last Updated : 02 Dec, 2024

Given an array arr[] of integers. In one operation you can choose an index i, and increment the element arr[i] by 1. The task is to return the minimum number of operations needed to make every value in the array arr[] unique.
Examples:

Input: arr[] = [3, 2, 1, 2, 1, 7]
Output: 6
Explanation: After 6 moves, the array could be [3, 4, 1, 2, 5, 7]. It can be shown that it is impossible for the array to have all unique values with 5 or less operations.

Input: arr[] = [1, 2, 2]
Output: 1
Explanation: After 1 operation [2 -> 3], the array could be [1, 2, 3].

Input: arr[] = [5, 4, 3, 2, 1]
Output: 0
Explanation: All elements are unique.

Table of Content

Expected Approach 1 – Use Sorting – O(n log(n)) Time and O(1) Space

The idea is to sort the array and then build a strictly increasing array by performing increment operations. Because elements in a strictly increasing array will always be unique.

Follow the given steps to solve the problem:

Sort the array in increasing order and initialize cnt to 0.
Starting from the second element, check if the current element is less than or equal to the previous element (Note that the previous element might become greater because of prior increment operations)
If the current element is less than or equal to the previous element, update current element = previous element + 1 to make it strictly increasing. Also, add the number of increments to cnt.

Illustration:

C++

// C++ Program to find minimum increment operations // to make array unique by sorting  #include <iostream> #include <vector> #include <algorithm> using namespace std;  int minIncrements(vector<int>& arr) {   	   	// sort the array in increasing order   	sort(arr.begin(), arr.end());      	int cnt = 0;   	for (int i = 1; i < arr.size(); i++) {              	// If current element <= the previous element     	if (arr[i] <= arr[i-1]) {           	           	// Make the array strictly increasing            	// by updating current element to            	// previous element + 1           	cnt += arr[i-1] + 1 - arr[i];           	arr[i] = arr[i-1] + 1;         }     }          return cnt; }  int main() {     vector<int> arr = {3, 2, 1, 2, 1, 7};     cout << minIncrements(arr); }

// C Program to find minimum increment operations // to make array unique by sorting #include <stdio.h> #include <stdlib.h>  // Comparator function for qsort int compare(const void *a, const void *b) {     return (*(int *)a - *(int *)b); }  int minIncrements(int arr[], int n) {          // sort the array in increasing order     qsort(arr, n, sizeof(int), compare);      int cnt = 0;     for (int i = 1; i < n; i++) {                  // If current element <= the previous element         if (arr[i] <= arr[i - 1]) {                          // Make the array strictly increasing              // by updating current element to              // previous element + 1;             cnt += arr[i - 1] + 1 - arr[i];             arr[i] = arr[i - 1] + 1;         }     }      return cnt; }  int main() {     int arr[] = {3, 2, 1, 2, 1, 7};     int size = sizeof(arr) / sizeof(arr[0]);      printf("%d\n", minIncrements(arr, size));     return 0; }

Java

// Java Program to find minimum increment operations // to make array unique by sorting import java.util.Arrays;  class GfG {     static int minIncrements(int[] arr) {                  // sort the array in increasing order         Arrays.sort(arr);                  int cnt = 0;         for (int i = 1; i < arr.length; i++) {                          // If current element <= the previous element             if (arr[i] <= arr[i - 1]) {                                  // Make the array strictly increasing                  // by updating current element to                  // previous element + 1;                 cnt += arr[i - 1] + 1 - arr[i];                 arr[i] = arr[i - 1] + 1;             }         }                  return cnt;     }      public static void main(String[] args) {         int[] arr = {3, 2, 1, 2, 1, 7};                  System.out.println(minIncrements(arr));     } }

Python

# Python Program to find minimum increment operations # to make array unique by sorting  def minIncrements(arr):          # sort the array in increasing order     arr.sort()          cnt = 0     for i in range(1, len(arr)):                  # If current element <= the previous element         if arr[i] <= arr[i - 1]:                          # Make the array strictly increasing              # by updating current element to              # previous element + 1;             cnt += arr[i - 1] + 1 - arr[i]             arr[i] = arr[i - 1] + 1          return cnt  if __name__ == "__main__":     arr = [3, 2, 1, 2, 1, 7]     print(minIncrements(arr))

// C# Program to find minimum increment operations // to make array unique by sorting using System; using System.Collections.Generic;  class GfG {     static int minIncrements(int[] arr) {                  // sort the array in increasing order         Array.Sort(arr);                  int cnt = 0;         for (int i = 1; i < arr.Length; i++) {                          // If current element <= the previous element             if (arr[i] <= arr[i - 1]) {                                  // Make the array strictly increasing                  // by updating current element to                  // previous element + 1;                 cnt += arr[i - 1] + 1 - arr[i];                 arr[i] = arr[i - 1] + 1;             }         }                  return cnt;     }      static void Main() {         int[] arr = {3, 2, 1, 2, 1, 7};                  Console.WriteLine(minIncrements(arr));     } }

JavaScript

// JavaScript Program to find minimum increment operations // to make array unique by sorting  function minIncrements(arr) {          // sort the array in increasing order     arr.sort((a, b) => a - b);          let cnt = 0;     for (let i = 1; i < arr.length; i++) {                  // If current element <= the previous element         if (arr[i] <= arr[i - 1]) {                          // Make the array strictly increasing              // by updating current element to              // previous element + 1;             cnt += arr[i - 1] + 1 - arr[i];             arr[i] = arr[i - 1] + 1;         }     }          return cnt; }  // Driver Code let arr = [3, 2, 1, 2, 1, 7]; console.log(minIncrements(arr));

Output

Expected Approach 2 – Use Frequency Array – O(n + max) Time and O(n + max) Space

The idea is to use a frequency array to count occurrences of each number in arr[], to make all elements unique. First, we create a sufficiently large frequency array based on the maximum element and size of array. Then, we iterate over this frequency array and check if the current number’s frequency is greater than 1. If it is, we increment all extra occurrences by 1 to make the current number unique. This process continues until all numbers are unique. Also we will count these increment operations during the iteration.

C++

// C++ Program to find the minimum increment operations // needed to make the array unique by using a frequency array  #include <iostream> #include <vector> #include <algorithm> using namespace std;  int minIncrements(vector<int>& arr) {     int n = arr.size();     int cnt = 0;          // Find the maximum element in the array     int mx = *max_element(arr.begin(), arr.end());     vector<int> freq(n + mx, 0);          // Find the frequency of all elements from the array     for (int ele : arr)          freq[ele]++;   	     for (int num = 0; num < freq.size(); num++) {                  // If there is more than one occurrence of num         if (freq[num] > 1) {                          // Increment all extra occurrences by 1              freq[num + 1] += freq[num] - 1;                          // Count these increment operations             cnt += freq[num] - 1;             freq[num] = 1;         }     }        return cnt; }  int main() {     vector<int> arr = {2, 1, 2, 4, 1};          cout << minIncrements(arr); }

Java

// Java Program to find the minimum increment operations // needed to make the array unique by using a frequency array import java.util.Arrays;  class GfG {     static int minIncrements(int[] arr) {                int n = arr.length;         int cnt = 0;          // Find the maximum element in the array         int mx = arr[0];       	for (int ele : arr)            	mx = Math.max(mx, ele);                int[] freq = new int[n + mx];          // Find the frequency of all elements from the array         for (int ele : arr)             freq[ele]++;          for (int num = 0; num < freq.length; num++) {                        // If there is more than one occurrence of num             if (freq[num] > 1) {                                // Increment all extra occurrences by 1                  freq[num + 1] += freq[num] - 1;                  // Count these increment operations                 cnt += freq[num] - 1;                 freq[num] = 1;             }         }          return cnt;     }      public static void main(String[] args) {         int[] arr = {2, 1, 2, 4, 1};         System.out.println(minIncrements(arr));     } }

Python

# Python Program to find the minimum increment operations # needed to make the array unique by using a frequency array  def minIncrements(arr):     n = len(arr)     cnt = 0          # Find the maximum element in the array     mx = max(arr)     freq = [0] * (n + mx)          # Find the frequency of all elements from the array     for ele in arr:         freq[ele] += 1          for num in range(len(freq)):                # If there is more than one occurrence of num         if freq[num] > 1:                        # Increment all extra occurrences by 1              freq[num + 1] += freq[num] - 1                          # Count these increment operations             cnt += freq[num] - 1             freq[num] = 1          return cnt  if __name__ == "__main__":     arr = [2, 1, 2, 4, 1]     print(minIncrements(arr))

// C# Program to find the minimum increment operations // needed to make the array unique by using a frequency array using System; class GfG {     static int minIncrements(int[] arr) {         int n = arr.Length;         int cnt = 0;          // Find the maximum element in the array         int mx = arr[0];         foreach (var ele in arr) {             if (ele > mx) mx = ele;         }          int[] freq = new int[n + mx];          // Find the frequency of all elements from the array         foreach (var ele in arr) {             freq[ele]++;         }          for (int num = 0; num < freq.Length; num++) {                        // If there are more than one occurrence of num             if (freq[num] > 1) {                                // Increment all extra occurrences by 1                  freq[num + 1] += freq[num] - 1;                  // Count these increment operations                 cnt += freq[num] - 1;                 freq[num] = 1;             }         }          return cnt;     }      static void Main() {         int[] arr = { 2, 1, 2, 4, 1 };         Console.WriteLine(minIncrements(arr));     } }

JavaScript

// JavaScript Program to find the minimum increment operations // needed to make the array unique by using a frequency array  function minIncrements(arr) {     const n = arr.length;     let cnt = 0;      // Find the maximum element in the array     const mx = Math.max(...arr);      const freq = new Array(n + mx).fill(0);      // Find the frequency of all elements from the array     arr.forEach(ele => {         freq[ele]++;     });      for (let num = 0; num < freq.length; num++) {              // If there is more than one occurrence of num         if (freq[num] > 1) {                      // Increment all extra occurrences by 1              freq[num + 1] += freq[num] - 1;              // Count these increment operations             cnt += freq[num] - 1;             freq[num] = 1;         }     }      return cnt; }  // Driver Code const arr = [2, 1, 2, 4, 1]; console.log(minIncrements(arr));

Output

Time Complexity: O(n + max), where n is the size of the array and max is its maximum element.
Auxiliary Space: O(n + max)

Distinct adjacent elements in a binary array

Sanjit_Prasad

Improve

Article Tags :

Practice Tags :

Minimum Increment operations to make Array unique

Expected Approach 1 – Use Sorting – O(n log(n)) Time and O(1) Space

Expected Approach 2 – Use Frequency Array – O(n + max) Time and O(n + max) Space

Similar Reads