 GFG App
Open App Browser
Continue

# Minimum delete operations to make all elements of array same

Given an array of n elements such that elements may repeat. We can delete any number of elements from the array. The task is to find a minimum number of elements to be deleted from the array to make it equal.
Examples:

```Input: arr[] = {4, 3, 4, 4, 2, 4}
Output: 2
After deleting 2 and 3 from array, array becomes
arr[] = {4, 4, 4, 4}

Input: arr[] = {1, 2, 3, 4, 5}
Output: 4
We can delete any four elements from array.```

In this problem, we need to minimize the delete operations. The approach is simple, we count the frequency of each element in an array, then find the frequency of the most frequent elements in count array. Let this frequency be max_freq. To get the minimum number of elements to be deleted from the array calculate n – max_freq where n is a number of elements in the given array.

## C++

 `// C++ program to find minimum` `// number of deletes required` `// to make all elements same.` `#include ` `using` `namespace` `std;`   `// Function to get minimum number of elements to be deleted` `// from array to make array elements equal` `int` `minDelete(``int` `arr[], ``int` `n)` `{` `    ``// Create an hash map and store frequencies of all` `    ``// array elements in it using element as key and` `    ``// frequency as value` `    ``unordered_map<``int``, ``int``> freq;` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``freq[arr[i]]++;`   `    ``// Find maximum frequency among all frequencies.` `    ``int` `max_freq = INT_MIN;` `    ``for` `(``auto` `itr = freq.begin(); itr != freq.end(); itr++)` `        ``max_freq = max(max_freq, itr->second);`   `    ``// To minimize delete operations, we remove all` `    ``// elements but the most frequent element.` `    ``return` `n - max_freq;` `}`   `// Driver program to run the case` `int` `main()` `{` `    ``int` `arr[] = { 4, 3, 4, 4, 2, 4 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``cout << minDelete(arr, n);` `    ``return` `0;` `}`

## Java

 `// Java program to find minimum number` `// of deletes required to make all` `// elements same.` `import` `java.util.*;`   `class` `GFG{`   `// Function to get minimum number of ` `// elements to be deleted from array` `// to make array elements equal` `static` `int` `minDelete(``int` `arr[], ``int` `n)` `{` `    `  `    ``// Create an hash map and store ` `    ``// frequencies of all array elements` `    ``// in it using element as key and` `    ``// frequency as value` `    ``HashMap freq = ``new` `HashMap<>();` `    ``for``(``int` `i = ``0``; i < n; i++)` `        ``freq.put(arr[i], freq.getOrDefault(arr[i], ``0``) + ``1``);`   `    ``// Find maximum frequency among all frequencies.` `    ``int` `max_freq = Integer.MIN_VALUE;` `    ``for``(Map.Entry entry : freq.entrySet())` `        ``max_freq = Math.max(max_freq, ` `                            ``entry.getValue());`   `    ``// To minimize delete operations, ` `    ``// we remove all elements but the` `    ``// most frequent element.` `    ``return` `n - max_freq ;` `}`   `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `arr[] = { ``4``, ``3``, ``4``, ``4``, ``2``, ``4` `};` `    ``int` `n = arr.length;` `    `  `    ``System.out.print(minDelete(arr, n));` `}` `}`   `// This code is contributed by amal kumar choubey and corrected by Leela Kotte`

## Python3

 `# Python3 program to find minimum ` `# number of deletes required to ` `# make all elements same. `   `# Function to get minimum number ` `# of elements to be deleted from ` `# array to make array elements equal ` `def` `minDelete(arr, n): ` `    `  `    ``# Create an dictionary and store ` `    ``# frequencies of all array ` `    ``# elements in it using ` `    ``# element as key and ` `    ``# frequency as value ` `    ``freq ``=` `{} ` `    ``for` `i ``in` `range``(n): ` `        ``if` `arr[i] ``in` `freq: ` `            ``freq[arr[i]] ``+``=` `1` `        ``else``: ` `            ``freq[arr[i]] ``=` `1``; ` `        `    `    ``# Find maximum frequency ` `    ``# among all frequencies. ` `    ``max_freq ``=` `0``; ` `    ``for` `i, j ``in` `freq.items(): ` `        ``max_freq ``=` `max``(max_freq, j); `   `    ``# To minimize delete operations, ` `    ``# we remove all elements but the ` `    ``# most frequent element. ` `    ``return` `n ``-` `max_freq; ` `    `  `# Driver code ` `arr ``=` `[ ``4``, ``3``, ``4``, ``4``, ``2``, ``4` `]; ` `n ``=` `len``(arr) `   `print``(minDelete(arr, n)); `   `# This code is contributed by grand_master `

## C#

 `// C# program to find minimum number` `// of deletes required to make all` `// elements same.` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG {`   `    ``// Function to get minimum number of` `    ``// elements to be deleted from array` `    ``// to make array elements equal` `    ``static` `int` `minDelete(``int``[] arr, ``int` `n)` `    ``{`   `        ``// Create an hash map and store` `        ``// frequencies of all array elements` `        ``// in it using element as key and` `        ``// frequency as value` `        ``Dictionary<``int``, ``int``> freq` `            ``= ``new` `Dictionary<``int``, ``int``>();` `        ``for` `(``int` `i = 0; i < n; i++)` `            ``if` `(freq.ContainsKey(arr[i])) ` `            ``{` `                ``freq[arr[i]] = freq[arr[i]] + 1;` `            ``}` `            ``else` `            ``{` `                ``freq.Add(arr[i], 1);` `            ``}`   `        ``// Find maximum frequency among all frequencies.` `        ``int` `max_freq = ``int``.MinValue;` `        ``foreach``(KeyValuePair<``int``, ``int``> entry ``in` `freq)` `            ``max_freq = Math.Max(max_freq, entry.Value);`   `        ``// To minimize delete operations,` `        ``// we remove all elements but the` `        ``// most frequent element.` `        ``return` `n - max_freq + 1;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``int``[] arr = {4, 3, 4, 4, 2, 4};` `        ``int` `n = arr.Length;` `          ``Console.Write(minDelete(arr, n));` `    ``}` `}`   `// This code is contributed by Amit Katiyar`

## Javascript

 ``

Output:

`2`

Time complexity: O(n)

Auxiliary Space: O(n)

Another Approach Using binary search :

• .First , we will sort the array for binary search function . Then we can find frequency of all array elements using lower_bound and upper bound .
• Then our answer will be n – max_frequency .

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above approach`   `#include ` `using` `namespace` `std;`   `// Function to find minimum operation required to` `// make all array elements equal` `int` `minDelete(``int` `arr[], ``int` `n)` `{  ` `   ``int` `max_freq = 1;` `   ``sort(arr,arr+n);``//sort array for binary search` `   `  `    ``// Iterating the whole array ` `   ``for``(``int` `i = 0 ; i < n ;i++)` `   ``{ ` `     ``//index of first and last occ of arr[i]` `     ``int` `first_index = lower_bound(arr,arr+n,arr[i])- arr;` `     ``int` `last_index = upper_bound(arr,arr+n,arr[i])- arr-1;` `     ``i = last_index; ``// assign i to last_index to avoid ` `                     ``// same element multiple time` `     `  `     ``int` `fre = last_index-first_index+1;``//finding frequency` `     `  `      ``// Finding maximum frequency from all array elements` `      ``max_freq = max( max_freq , fre );` `   ``} ` `   ``return` `n-max_freq;``// return answer` `}`   `// Drive code` `int` `main()` `{  ` `    ``int` `arr[] = { 4, 3, 4, 4, 2, 4 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `   `  `    ``// Function call` `    ``cout << minDelete(arr, n);` `    `  `    ``return` `0;` `}`   `// This Approach is contributed by nikhilsainiofficial546`

## Java

 `import` `java.util.Arrays;`   `public` `class` `Main {` `    ``// Function to find minimum operation required to make all ` `   ``// array elements equal` `    ``public` `static` `int` `minDelete(``int``[] arr) {` `        ``int` `n = arr.length;` `        ``int` `max_freq = ``1``;` `        ``Arrays.sort(arr); ``// sort array for binary search`   `        ``// Iterating the whole array` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``// index of first and last occurrence of arr[i]` `            ``int` `first_index = Arrays.binarySearch(arr, arr[i]);` `            ``int` `last_index = first_index;` `            ``while` `(last_index < n - ``1` `&& arr[last_index + ``1``] == arr[i]) {` `                ``last_index++;` `            ``}` `            ``i = last_index; ``// assign i to last_index to avoid same element multiple times`   `            ``int` `fre = last_index - first_index + ``1``; ``// finding frequency`   `            ``// Finding maximum frequency from all array elements` `            ``max_freq = Math.max(max_freq, fre);` `        ``}` `        ``return` `n - max_freq; ``// return answer` `    ``}`   `    ``public` `static` `void` `main(String[] args) {` `        ``int``[] arr = {``4``, ``3``, ``4``, ``4``, ``2``, ``4``};` `        ``System.out.println(minDelete(arr));` `    ``}` `}`

## Python3

 `# Function to find minimum operation required to` `# make all array elements equal` `def` `minDelete(arr, n):` `    ``max_freq ``=` `1` `    ``arr.sort() ``# sort array for binary search`   `    ``# Iterating the whole array` `    ``i ``=` `0` `    ``while` `i < n:` `      `  `        ``# index of first occ of arr[i]` `        ``first_index ``=` `arr.index(arr[i])` `        `  `        ``# find the last occ of arr[i]` `        ``j ``=` `n ``-` `1` `        ``while` `j >``=` `0` `and` `arr[j] !``=` `arr[i]:` `            ``j ``-``=` `1` `        ``last_index ``=` `j` `        ``fre ``=` `last_index ``-` `first_index ``+` `1` `# finding frequency` `        ``# Finding maximum frequency from all array elements` `        ``max_freq ``=` `max``(max_freq, fre)`   `        ``i ``=` `last_index ``+` `1` `# assign i to next index`   `    ``return` `n ``-` `max_freq ``# return answer`   `# Drive code` `arr ``=` `[``4``, ``3``, ``4``, ``4``, ``2``, ``4``]` `n ``=` `len``(arr)`   `# Function call` `print``(minDelete(arr, n))`

## C#

 `using` `System;`   `class` `Program {`   `  ``// Function to find minimum operation required to` `  ``// make all array elements equal` `  ``static` `int` `minDelete(``int``[] arr, ``int` `n)` `  ``{` `    ``int` `max_freq = 1;` `    ``Array.Sort(arr); ``// sort array for binary search`   `    ``// Iterating the whole array` `    ``for` `(``int` `i = 0; i < n; i++) {` `      ``// index of first and last occ of arr[i]` `      ``int` `first_index` `        ``= Array.BinarySearch(arr, arr[i]);` `      ``int` `last_index = Array.LastIndexOf(arr, arr[i]);` `      ``i = last_index; ``// assign i to last_index to` `      ``// avoid same element multiple` `      ``// time`   `      ``int` `fre = last_index - first_index` `        ``+ 1; ``// finding frequency`   `      ``// Finding maximum frequency from all array` `      ``// elements` `      ``max_freq = Math.Max(max_freq, fre);` `    ``}` `    ``return` `n - max_freq; ``// return answer` `  ``}`   `  ``static` `void` `Main(``string``[] args)` `  ``{` `    ``int``[] arr = { 4, 3, 4, 4, 2, 4 };` `    ``int` `n = arr.Length;`   `    ``// Function call` `    ``Console.WriteLine(minDelete(arr, n));` `  ``}` `}`   `// This code is contributed by sarojmcy2e`

## Javascript

 `// Function to find minimum operation required to` `// make all array elements equal` `function` `minDelete(arr, n) {` `  ``let max_freq = 1;` `  ``arr.sort((a, b) => a - b); ``// sort array for binary search`   `  ``// Iterating the whole array` `  ``for` `(let i = 0; i < n; i++) {` `    ``// index of first and last occ of arr[i]` `    ``let first_index = arr.indexOf(arr[i]);` `    ``let last_index = arr.lastIndexOf(arr[i]);` `    ``i = last_index; ``// assign i to last_index to avoid` `    ``// same element multiple time`   `    ``let fre = last_index - first_index + 1; ``// finding frequency`   `    ``// Finding maximum frequency from all array elements` `    ``max_freq = Math.max(max_freq, fre);` `  ``}` `  ``return` `n - max_freq; ``// return answer` `}`   `// Drive code` `let arr = [4, 3, 4, 4, 2, 4];` `let n = arr.length;`   `// Function call` `console.log(minDelete(arr, n));`

Output

`2`

Time Complexity: O(N*Log2N), where N is the size of the input array
Auxiliary Space: O(1)

Note: Here we can optimize the extra space to count the frequency of each element to O(1) but for this, we have to modify our original array. See this article.

This article is contributed by Aarti_Rathi and Shashank Mishra ( Gullu ). If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.