# Minimum changes required to make all element in an array equal

Given an array of length N, the task is to find minimum operation required to make all elements in the array equal.

Operation is as follows:

• Replace the value of one element of the array by one of its adjacent elements.
• Examples:

```Input: N = 4, arr[] = {2, 3, 3, 4}
Output: 2
Explanation:
Replace 2 and 4 by 3

Input: N = 4, arr[] = { 1, 2, 3, 4}
Output: 4
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

Let us assume that after performing the required minimum changes all elements of the array will become X. It is given that we are only allowed to replace the value of an element of the array with its adjacent element, So X should be one of the elements of the array.

Also, as we need to make changes as minimum as possible X should be the maximum occurring element of the array. Once we find the value of X, we need only one change per non-equal element (elements which are not X) to make all elements of the array equal to X.

• Find the count of the maximum occurring element of the array.
• Minimum changes required to make all elements of the array equal is
count of all elements – count of maximum occurring element

Below is the implementation of above approach:

## CPP

 `// C++ program to find minimum ` `// changes required to make ` `// all elements of the array equal ` `#include ` `using` `namespace` `std; ` ` `  `// Function to count ` `// of minimum changes ` `// required to make all ` `// elements equal ` `int` `minChanges(``int` `arr[], ``int` `n) ` `{ ` ` `  `    ``unordered_map<``int``, ``int``> umap; ` ` `  `    ``// Store the count of ` `    ``// each element as key ` `    ``// value pair in unordered map ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``umap[arr[i]]++; ` `    ``} ` ` `  `    ``int` `maxFreq = 0; ` ` `  `    ``// Find the count of ` `    ``// maximum occurring element ` `    ``for` `(``auto` `p : umap) { ` `        ``maxFreq = max(maxFreq, p.second); ` `    ``} ` ` `  `    ``// Return count of all ` `    ``// element minus count ` `    ``// of maximum occurring element ` `    ``return` `n - maxFreq; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` ` `  `    ``int` `arr[] = { 2, 3, 3, 4 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` ` `  `    ``cout << minChanges(arr, n) << ``'\n'``; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to find minimum ` `// changes required to make ` `// all elements of the array equal ` `import` `java.util.*; ` ` `  `class` `GFG { ` ` `  `    ``// Function to count of minimum changes ` `    ``// required to make all elements equal ` `    ``static` `int` `minChanges(``int` `arr[], ``int` `n) ` `    ``{ ` ` `  `        ``Map mp = ``new` `HashMap<>(); ` ` `  `        ``// Store the count of each element ` `        ``// as key value pair in map ` `        ``for` `(``int` `i = ``0``; i < n; i++) { ` `            ``if` `(mp.containsKey(arr[i])) { ` `                ``mp.put(arr[i], mp.get(arr[i]) + ``1``); ` `            ``} ` ` `  `            ``else` `{ ` `                ``mp.put(arr[i], ``1``); ` `            ``} ` `        ``} ` ` `  `        ``int` `maxElem = ``0``; ` ` `  `        ``// Traverse through map and ` `        ``// find the maximum occurring element ` `        ``for` `(Map.Entry entry : mp.entrySet()) { ` ` `  `            ``maxElem = Math.max(maxElem, entry.getValue()); ` `        ``} ` ` `  `        ``// Return count of all element minus ` `        ``// count of maximum occurring element ` `        ``return` `n - maxElem; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` ` `  `        ``int` `arr[] = { ``2``, ``3``, ``3``, ``4` `}; ` ` `  `        ``int` `n = arr.length; ` ` `  `        ``System.out.println(minChanges(arr, n)); ` `    ``} ` `} `

## C#

 `// C# program to find minimum ` `// changes required to make ` `// all elements of the array equal ` ` `  `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG { ` ` `  `    ``// Function to count of minimum changes ` `    ``// required to make all elements equal ` `    ``static` `int` `minChanges(``int``[] arr, ``int` `n) ` `    ``{ ` ` `  `        ``Dictionary<``int``, ``int``> mp = ``new` `Dictionary<``int``, ``int``>(); ` ` `  `        ``// Store the count of each element ` `        ``// as key-value pair in Dictionary ` ` `  `        ``for` `(``int` `i = 0; i < n; i++) { ` `            ``if` `(mp.ContainsKey(arr[i])) { ` `                ``var` `val = mp[arr[i]]; ` `                ``mp.Remove(arr[i]); ` `                ``mp.Add(arr[i], val + 1); ` `            ``} ` `            ``else` `{ ` `                ``mp.Add(arr[i], 1); ` `            ``} ` `        ``} ` ` `  `        ``int` `maxElem = 0; ` ` `  `        ``// Traverse through the Dictionary and ` `        ``// find the maximum occurring element ` `        ``foreach``(KeyValuePair<``int``, ``int``> entry ``in` `mp) ` `        ``{ ` `            ``maxElem = Math.Max(maxElem, entry.Value); ` `        ``} ` ` `  `        ``// Return count of all element minus ` `        ``// count of maximum occurring element ` `        ``return` `n - maxElem; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(``string``[] args) ` `    ``{ ` ` `  `        ``int``[] arr = { 2, 3, 3, 4 }; ` ` `  `        ``int` `n = arr.Length; ` ` `  `        ``Console.WriteLine(minChanges(arr, n)); ` `    ``} ` `} `

## Python3

 `# Python3 program to find minimum ` `# changes required to make ` `# all elements of the array equal ` ` `  ` `  `# Function to count of minimum changes ` `# required to make all elements equal ` `def` `minChanges(arr, n): ` ` `  `     `  `    ``mp ``=` `dict``()  ` ` `  `    ``# Store the count of each element ` `    ``# as key-value pair in Dictionary  ` ` `  `    ``for` `i ``in` `range``(n):  ` `        ``if` `arr[i] ``in` `mp.keys():  ` `            ``mp[arr[i]] ``+``=` `1` `        ``else``:  ` `            ``mp[arr[i]] ``=` `1` `     `  `     `  `    ``maxElem ``=` `0` `         `  `    ``# Traverse through the Dictionary and  ` `    ``# find the maximum occurring element ` `     `  `    ``for` `x ``in` `mp:  ` `        ``maxElem ``=` `max``(maxElem, mp[x])  ` `         `  `    ``# Return count of all element minus ` `    ``# count of maximum occurring element  ` `    ``return` `n ``-` `maxElem ` `         `  `         `  `# Driver code ` `         `  `arr ``=` `[``2``, ``3``, ``3``, ``4` `] ` `n ``=` `len``(arr) ` `print``(minChanges(arr, n)) ` ` `

Output:

```2
```

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.