# Make all array elements equal by repeatedly replacing largest array element with the second smallest element

Given an array **arr[]** of size **N**, the task is to count the number of operations required to make all array elements equal by replacing the **largest** array element with the second-largest array element, which is **strictly** smaller than the largest array element.

**Examples:**

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.

Input:arr[ ] = {1, 1, 2, 2, 3}Output:4Explanation:A total of 4 operations are required to make all array elements equal.Operation 1:Replace the largest element (= arr[4] = 3) with the next largest( = arr[2] = 2). The array arr[] modifies to {1, 1, 2, 2,2}.Operation 2:Replace the largest element (= arr[2] = 2) with the next largest( = arr[0] = 1). The array arr[] modifies to {1, 1,1, 2, 2}Operation 3:Replace the largest element (= arr[3] = 2) with the next largest( = arr[0] = 1). The array arr[] modifies to {1, 1, 1,1, 2}Operation 4:Replace the largest element (= arr[4] = 2) with the next largest( = arr[0] = 1). The array arr[] modifies to {1, 1, 1, 1,1}

Input:arr[ ] = {1, 1, 1}Output:0

**Approach: **Follow the steps below to solve the problem:

- Initialize a variable, say
**value_count = 0**and**operation_count = 0**. - Sort the array
**arr[]**in ascending order. - Traverse the array
**arr[]**and check if the current element is greater than the previous element. If found to be true**,**then increase**value_count**by**1**. - For each iteration, add
**value_count**in**operation_count**. - Finally, print the value of
**operation_count**.

Below is the implementation of the above approach:

## C++

`// C++ program to Make all array elements` `// equal by perform certain operation` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to count number of operations` `// required to make all array elements equal` `int` `operation(` `int` `arr[], ` `int` `n)` `{` ` ` `// Initialize the val_count` ` ` `// and operation_count by 0.` ` ` `int` `val_count = 0, operation_count = 0;` ` ` `// Sort the array in ascending order.` ` ` `sort(arr, arr + n);` ` ` `for` `(` `int` `i = 1; i < n; i++) {` ` ` `// Current element greater` ` ` `// than the previous element` ` ` `if` `(arr[i - 1] < arr[i]) {` ` ` `// If yes then update the` ` ` `// val_count by 1.` ` ` `val_count++;` ` ` `}` ` ` `// Add the value_count in operation_count.` ` ` `operation_count = operation_count + val_count;` ` ` `}` ` ` `// Return the operation_count` ` ` `return` `operation_count;` `}` `// Driver Code` `int` `main()` `{` ` ` `// Given Input` ` ` `int` `arr[] = { 1, 1, 2, 2, 3 };` ` ` `int` `n = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]);` ` ` `// Function Call` ` ` `cout << operation(arr, n);` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.util.Arrays;` `import` `java.io.*;` `class` `GFG` `{` ` ` `// Function to count number of operations` ` ` `// required to make all array elements equal` ` ` `static` `int` `operation(` `int` `arr[], ` `int` `n)` ` ` `{` ` ` `// Initialize the val_count` ` ` `// and operation_count by 0.` ` ` `int` `val_count = ` `0` `, operation_count = ` `0` `;` ` ` `// Sort the array in ascending order.` ` ` `Arrays.sort(arr);` ` ` `for` `(` `int` `i = ` `1` `; i < n; i++) {` ` ` `// Current element greater` ` ` `// than the previous element` ` ` `if` `(arr[i - ` `1` `] < arr[i]) {` ` ` `// If yes then update the` ` ` `// val_count by 1.` ` ` `val_count++;` ` ` `}` ` ` `// Add the value_count in operation_count.` ` ` `operation_count = operation_count + val_count;` ` ` `}` ` ` `// Return the operation_count` ` ` `return` `operation_count;` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `main (String[] args)` ` ` `{` ` ` `// Given Input` ` ` `int` `arr[] = { ` `1` `, ` `1` `, ` `2` `, ` `2` `, ` `3` `};` ` ` `int` `n = arr.length;` ` ` `// Function Call` ` ` `System.out.println( operation(arr, n));` ` ` `}` `}` `// This code is contributed by Potta Lokesh` |

## Python3

`# Python3 program to Make all array elements` `# equal by perform certain operation` `# Function to count number of operations` `# required to make all array elements equal` `def` `operation(arr, n):` ` ` ` ` `# Initialize the val_count` ` ` `# and operation_count by 0.` ` ` `val_count ` `=` `0` ` ` `operation_count ` `=` `0` ` ` ` ` `# Sort the array in ascending order.` ` ` `arr.sort()` ` ` `for` `i ` `in` `range` `(` `1` `, n):` ` ` ` ` `# Current element greater` ` ` `# than the previous element` ` ` `if` `arr[i` `-` `1` `] < arr[i]:` ` ` ` ` `# If yes then update the` ` ` `# val_count by 1.` ` ` `val_count ` `+` `=` `1` ` ` ` ` `# Add the value_count in operation_count. ` ` ` `operation_count ` `+` `=` `val_count` ` ` ` ` `# Return the operation_count` ` ` `return` `operation_count` `# Driver code` `arr ` `=` `[` `1` `, ` `1` `, ` `2` `, ` `2` `, ` `3` `]` `n ` `=` `len` `(arr)` `print` `(operation(arr, n))` `# This code is contributed by Parth Manchanda` |

## C#

`// C# program for the above approach` `using` `System;` `public` `class` `GFG` `{` ` ` `// Function to count number of operations` ` ` `// required to make all array elements equal` ` ` `static` `int` `operation(` `int` `[]arr, ` `int` `n)` ` ` `{` ` ` `// Initialize the val_count` ` ` `// and operation_count by 0.` ` ` `int` `val_count = 0, operation_count = 0;` ` ` `// Sort the array in ascending order.` ` ` `Array.Sort(arr);` ` ` `for` `(` `int` `i = 1; i < n; i++) {` ` ` `// Current element greater` ` ` `// than the previous element` ` ` `if` `(arr[i - 1] < arr[i]) {` ` ` `// If yes then update the` ` ` `// val_count by 1.` ` ` `val_count++;` ` ` `}` ` ` `// Add the value_count in operation_count.` ` ` `operation_count = operation_count + val_count;` ` ` `}` ` ` ` ` `// Return the operation_count` ` ` `return` `operation_count;` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `Main(String[] args)` ` ` `{` ` ` `// Given Input` ` ` `int` `[]arr = { 1, 1, 2, 2, 3 };` ` ` `int` `n = arr.Length;` ` ` `// Function Call` ` ` `Console.WriteLine( operation(arr, n));` ` ` `}` `}` `// This code is contributed by Amit Katiyar` |

## Javascript

`// Javascript program to Make all array elements` `// equal by perform certain operation` `// Function to count number of operations` `// required to make all array elements equal` `function` `operation(arr, n) {` ` ` `// Initialize the val_count` ` ` `// and operation_count by 0.` ` ` `let val_count = 0,` ` ` `operation_count = 0;` ` ` `// Sort the array in ascending order.` ` ` `arr.sort();` ` ` `for` `(let i = 1; i < n; i++) {` ` ` `// Current element greater` ` ` `// than the previous element` ` ` `if` `(arr[i - 1] < arr[i]) {` ` ` `// If yes then update the` ` ` `// val_count by 1.` ` ` `val_count++;` ` ` `}` ` ` `// Add the value_count in operation_count.` ` ` `operation_count = operation_count + val_count;` ` ` `}` ` ` `// Return the operation_count` ` ` `return` `operation_count;` `}` `// Driver Code` `// Given Input` `let arr = [1, 1, 2, 2, 3];` `let n = arr.length;` `// Function Call` `document.write(operation(arr, n));` `// This code is contributed by gfgking.` |

**Output:**

4

**Time Complexity:** O(NLogN)**Auxiliary Space: **O(1)