Given a sorted array A[] of length N. For each i(0 ≤ i ≤ n-1), you have to make all the elements of the array from index 0 to i equal, using the minimum number of operations. In one operation you either increase or decrease the array element by 1. the task is to return a list that contains the minimum number of operations for each i, to accomplish the above task.
Note:
- 0-based indexing.
- For each index, you need to consider the same array which was given to you at the start.
Examples:
Input: N = 4, A[] = {1, 6, 9, 12}
Output: 0 5 8 14Input: N = 7, A[] ={1, 1, 1, 7, 7, 10, 19}
Output: 0 0 0 6 12 21 33
Explanation: Possible operations could be:
{1}->{1}
{1, 1}->{1, 1}
{1, 1, 1}->{1, 1, 1}
{1, 1, 1, 7}->{1, 1, 1, 1}
{1, 1, 1, 7, 7}->{1, 1, 1, 1, 1}
{1, 1, 1, 7, 7, 10}->{5, 5, 5, 5, 5, 5}
{1, 1, 1, 7, 7, 10, 19}->{7, 7, 7, 7, 7, 7, 7}
Approach: This can be solved by the following idea:
We basically apply the concept of median here as there will be less operation required in changing all elements into their median but here we need to focus on one point if we take the median for odd n/2 and even n/2 + n/2+ 1 average then we will require two loops and we run out of the time (TLE) so we will take median as n/2 and subtract it from every value and then all it and it will be our answer or we can say that just add (i-1)th element operation with a value of i index subtracting medium from it.
Steps involved in the implementation of the code:
- Initialize an array of the long type which will store the value of the minimum operation required and name it “ans”.
- Set the 0th index value of ans = 0 because any value is equal to itself.
- Take an integer variable let’s name it “res” initialize it with 1 and use it as the reference index of ans.
- Start the for loop and inside it set the condition ans[res] = ans[i-1]+(a[i]-a[i/2]) which means the operation required to change all values from 0th to i-1 index + value of ith index – median value and assign this value in ans.
- Increment “res” by 1 to go to the next index of ans and store its value in the next iteration.
Below is the code of the above approach:
#include <iostream> #include <vector> using namespace std;
// Function to find minimum number of operations required to // make all elements equal vector< long long > optimalArray( int n, int a[])
{ // Vector to store minimum operation
vector< long long > ans(n);
// Set minimum operation of array with 1 element as 0
ans[0] = 0;
// Create a variable for reference index of ans vector
int res = 1;
for ( int i = 1; i < n; i++) {
// Operation required for i-1th element + value of
// ith index - median
ans[res] = ans[i - 1] + (a[i] - a[i / 2]);
res++;
}
return ans;
} // Function to print a vector void printArray(vector< long long > arr, int size)
{ for ( int i = 0; i < size; i++)
cout << arr[i] << " " ;
cout << endl;
} // Driver code int main()
{ int n = 4;
int a[] = { 1, 6, 9, 12 };
// Function call
vector< long long > ans = optimalArray(n, a);
printArray(ans, n);
return 0;
} |
// Java code for the above approach: import java.io.*;
class GFG {
// Function to find minimum number of
// operations required to make
// all elements equal
static public long [] optimalArray( int n, int a[])
{
// Array to store minimum
// operation
long ans[] = new long [n];
// Set minimum operation of array
// with 1 element as 0
ans[ 0 ] = 0 ;
// Create a variable for reference
// index of ans array
int res = 1 ;
for ( int i = 1 ; i < n; i++) {
// operation required for i-1th
// element + value of ith
// index - median
ans[res] = ans[i - 1 ] + (a[i] - a[i / 2 ]);
res++;
}
return ans;
}
// Function to print an array
static void printArray( long arr[], int size)
{
for ( int i = 0 ; i < size; i++)
System.out.print(arr[i] + " " );
System.out.println();
}
// Driver code
public static void main(String[] args)
{
int n = 4 ;
int [] a = { 1 , 6 , 9 , 12 };
// Function call
long [] ans = optimalArray(n, a);
printArray(ans, n);
}
} |
# Python code for the above approach: # Function to find minimum number of # operations required to make # all elements equal def optimalArray(n, a):
# Array to store minimum
# operation
ans = [ 0 ] * n
# Set minimum operation of array
# with 1 element as 0
ans[ 0 ] = 0
# Create a variable for reference
# index of ans array
res = 1
for i in range ( 1 , n):
# operation required for i-1th
# element + value of ith
# index - median
ans[res] = ans[i - 1 ] + (a[i] - a[i / / 2 ])
res + = 1
return ans
# Function to print an array def printArray(arr, size):
for i in range (size):
print (arr[i], end = ' ' )
print ()
# Driver code n = 4
a = [ 1 , 6 , 9 , 12 ]
# Function call ans = optimalArray(n, a)
printArray(ans, n) # This code is contributed by prasad264 |
// Function to find minimum number of operations required to make // all elements equal function optimalArray(n, a)
{ // Vector to store minimum operation
const ans = new Array(n);
// Set minimum operation of array with 1 element as 0
ans[0] = 0;
// Create a variable for reference index of ans vector
let res = 1;
for (let i = 1; i < n; i++) {
// Operation required for i-1th element + value of ith index - median
ans[res] = ans[i - 1] + (a[i] - a[Math.floor(i / 2)]);
res++;
}
return ans;
} // Function to print a vector function printArray(arr, size) {
for (let i = 0; i < size; i++)
process.stdout.write(arr[i] + " " );
} // Driver code const n = 4; const a = [1, 6, 9, 12]; // Function call const ans = optimalArray(n, a); printArray(ans, n); |
using System;
using System.Collections.Generic;
public class Program {
// Function to find minimum number of operations
// required to make all elements equal
static List< long > OptimalArray( int n, int [] a)
{
// List to store minimum operation
List< long > ans = new List< long >(n);
// Set minimum operation of array with 1 element as
// 0
ans.Add(0);
// Create a variable for reference index of ans
// vector
int res = 1;
for ( int i = 1; i < n; i++) {
// Operation required for i-1th element + value
// of ith index - median
ans.Add(ans[i - 1] + (a[i] - a[i / 2]));
res++;
}
return ans;
}
// Function to print a list
static void PrintArray(List< long > arr, int size)
{
for ( int i = 0; i < size; i++)
Console.Write(arr[i] + " " );
Console.WriteLine();
}
// Driver code
static void Main()
{
int n = 4;
int [] a = { 1, 6, 9, 12 };
// Function call
List< long > ans = OptimalArray(n, a);
PrintArray(ans, n);
}
} |
0 5 8 14
Time Complexity: O(n), where n is the size of the array ‘a’, because the code contains a single for-loop that iterates n-1 times. Therefore, the time complexity is linear in terms of the input size.
Auxiliary Space: O(n), because it creates a vector ‘ans’ of size n to store the minimum operations required to make all elements equal. Therefore, the space complexity is also linear in terms of the input size.