Related Articles

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

• Difficulty Level : Medium
• Last Updated : 09 Aug, 2021

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:

Input: arr[ ] = {1, 1, 2, 2, 3}
Output: 4
Explanation: A total of 4 operations are required to make all array elements equal.
Operation 1: Replace the largest element (= arr = 3) with the next largest( = arr = 2). The array arr[] modifies to {1, 1, 2, 2, 2}.
Operation 2: Replace the largest element (= arr = 2) with the next largest( = arr = 1). The array arr[] modifies to {1, 1, 1, 2, 2}
Operation 3:  Replace the largest element (= arr = 2) with the next largest( = arr = 1). The array arr[] modifies to {1, 1, 1, 1, 2}
Operation 4:  Replace the largest element (= arr = 2) with the next largest( = arr = 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 ``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);` `    ``// 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)

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.

My Personal Notes arrow_drop_up