# Optimal Array

Last Updated : 10 Apr, 2023

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 14

Input: 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:

## C++14

 `#include ` `#include ` `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

 `// 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);` `    ``}` `}`

## Python3

 `# 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`

## Javascript

 `// 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);`

## C#

 `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);` `    ``}` `}`

Output

`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.