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[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++ 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 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 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# 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 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. |
4
Time Complexity: O(NLogN)
Auxiliary Space: O(1)