Related Articles

# Minimum operations required to make all elements in an array of first N odd numbers equal

• Last Updated : 27 May, 2021

Given an array consisting of first N odd numbers, the task is to find the minimum number of operations required to make all the array elements equal by repeatedly selecting a pair and incrementing one element and decrementing the other element in the pair by 1.

Examples:

Input: N = 3
Output: 2
Explanation:
Initially, the array is {1, 3, 5}. Following operations are performed:
Operation 1: Decrement arr by 1 and increment arr by 1. The array modifies to {2, 3, 4}.
Operation 2: Decrement arr by 1 and increment arr by 1. The array modifies to {3, 3, 3}.
Therefore, the minimum number of operations required is 2.

Input: N = 6
Output: 9

Naive Approach: The given problem can be solved based on the following observations:

• It can be observed that making all the array elements equal to the middle element of the array requires minimum number of operations.
• Therefore, the idea is to traverse the array using a variable i and select the element at index i and (N – i – 1) in each operation and make them equal to the middle element.

Follow the steps below to solve the problem:

• Initialize a variable, say mid, that stores the middle element of the array.
• Initialize an array arr[] that stores the array element as arr[i] = 2 * i + 1.
• Find the sum of the array arr[] and store it in a variable say sum.
• If N is odd, then update the value of mid to arr[N / 2]. Otherwise, update the value of mid to sum / N.
• Initialize a variable, say ans as 0 that stores the minimum number of operations.
• Traverse the given array over the range [0, N/2] and increment the value of ans by the value (mid – arr[i]).
• After completing the above steps, print the value of ans as the result.

Below is the implementation of the above approach:

## C++14

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the minimum number``// of operations required to make the``// array elements equal``int` `minOperations(``int` `N)``{``    ` `    ``// Stores the array elements``    ``int` `arr[N];` `    ``// Stores the sum of the array``    ``int` `sum = 0;` `    ``// Iterate over the range [0, N]``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ` `        ``// Update the value arr[i]``        ``arr[i] = (2 * i) + 1;` `        ``// Increment the sum by``        ``// the value arr[i]``        ``sum = sum + arr[i];``    ``}` `    ``// Stores the middle element``    ``int` `mid = 0;` `    ``// If N is even``    ``if` `(N % 2 == 0)``    ``{``        ``mid = sum / N;``    ``}` `    ``// Otherwise``    ``else` `{``        ``mid = arr[N / 2];``    ``}` `    ``// Stores the result``    ``int` `ans = 0;` `    ``// Traverse the range [0, N / 2]``    ``for``(``int` `i = 0; i < N / 2; i++)``    ``{``        ` `        ``// Update the value of ans``        ``ans += mid - arr[i];``    ``}` `    ``// Return the result``    ``return` `ans;``}``    ` `// Driver Code``int` `main()``{``    ``int` `N = 6;``    ``cout << minOperations(N);` `    ``return` `0;``}` `// This code is contributed by susmitakundugoaldanga`

## Java

 `// Java program for the above approach` `class` `GFG {` `    ``// Function to find the minimum number``    ``// of operations required to make the``    ``// array elements equal``    ``public` `static` `int` `minOperations(``int` `N)``    ``{``        ``// Stores the array elements``        ``int``[] arr = ``new` `int``[N];` `        ``// Stores the sum of the array``        ``int` `sum = ``0``;` `        ``// Iterate over the range [0, N]``        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``// Update the value arr[i]``            ``arr[i] = (``2` `* i) + ``1``;` `            ``// Increment the sum by``            ``// the value arr[i]``            ``sum = sum + arr[i];``        ``}` `        ``// Stores the middle element``        ``int` `mid = ``0``;` `        ``// If N is even``        ``if` `(N % ``2` `== ``0``) {``            ``mid = sum / N;``        ``}` `        ``// Otherwise``        ``else` `{``            ``mid = arr[N / ``2``];``        ``}` `        ``// Stores the result``        ``int` `ans = ``0``;` `        ``// Traverse the range [0, N / 2]``        ``for` `(``int` `i = ``0``; i < N / ``2``; i++) {` `            ``// Update the value of ans``            ``ans += mid - arr[i];``        ``}` `        ``// Return the result``        ``return` `ans;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `N = ``6``;``        ``System.out.println(``            ``minOperations(N));``    ``}``}`

## Python3

 `# Python3 program for the above approach` `# Function to find the minimum number``# of operations required to make the``# array elements equal``def` `minOperations(N):``    ` `    ``# Stores the array elements``    ``arr ``=` `[``0``] ``*` `N` `    ``# Stores the sum of the array``    ``sum` `=` `0` `    ``# Iterate over the range [0, N]``    ``for` `i ``in` `range``(N) :``        ` `        ``# Update the value arr[i]``        ``arr[i] ``=` `(``2` `*` `i) ``+` `1` `        ``# Increment the sum by``        ``# the value arr[i]``        ``sum` `=` `sum` `+` `arr[i]` `    ``# Stores the middle element``    ``mid ``=` `0` `    ``# If N is even``    ``if` `N ``%` `2` `=``=` `0` `:``        ``mid ``=` `sum` `/` `N` `    ``# Otherwise``    ``else``:``        ``mid ``=` `arr[``int``(N ``/` `2``)]` `    ``# Stores the result``    ``ans ``=` `0` `    ``# Traverse the range [0, N / 2]``    ``for` `i ``in` `range``(``int``(N ``/` `2``)):``        ` `        ``# Update the value of ans``        ``ans ``+``=` `mid ``-` `arr[i]` `    ``# Return the result``    ``return` `int``(ans)``    ` `# Driver Code``N ``=` `6``print``(minOperations(N))` `# This code is contributed by Dharanendra L V.`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to find the minimum number``// of operations required to make the``// array elements equal``public` `static` `int` `minOperations(``int` `N)``{``    ` `    ``// Stores the array elements``    ``int``[] arr = ``new` `int``[N];` `    ``// Stores the sum of the array``    ``int` `sum = 0;` `    ``// Iterate over the range [0, N]``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ` `        ``// Update the value arr[i]``        ``arr[i] = (2 * i) + 1;` `        ``// Increment the sum by``        ``// the value arr[i]``        ``sum = sum + arr[i];``    ``}` `    ``// Stores the middle element``    ``int` `mid = 0;` `    ``// If N is even``    ``if` `(N % 2 == 0)``    ``{``        ``mid = sum / N;``    ``}` `    ``// Otherwise``    ``else``    ``{``        ``mid = arr[N / 2];``    ``}` `    ``// Stores the result``    ``int` `ans = 0;` `    ``// Traverse the range [0, N / 2]``    ``for``(``int` `i = 0; i < N / 2; i++)``    ``{``        ` `        ``// Update the value of ans``        ``ans += mid - arr[i];``    ``}` `    ``// Return the result``    ``return` `ans;``}` `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``    ``int` `N = 6;``    ` `    ``Console.WriteLine(minOperations(N));``}``}` `// This code is contributed by ukasp`

## Javascript

 ``
Output:
`9`

Time Complexity: O(N)
Auxiliary Space: O(N)

Efficient Approach: The above approach can be optimized based on the following observation:

Therefore, if the value of N is even, then print the value of (N / 2)2. Otherwise, print the value of K * (K + 1) / 2, where K = ((N – 1) / 2) as the resultant operation.

Below is the implementation of the above approach:

## C++

 `// C++ code for the above approach``#include ``using` `namespace` `std;` `// Function to find the minimum number``    ``// of operations required to make the``    ``// array elements equal``    ``int` `minOperation(``int` `N)``    ``{``        ``// If the value of N is even``        ``if` `(N % 2 == 0) {`` ` `            ``// Return the value``            ``return` `(N / 2) * (N / 2);``        ``}`` ` `        ``// Otherwise, N is odd``        ``int` `k = (N - 1) / 2;`` ` `        ``// Return the value``        ``return` `k * (k + 1);``    ``}``    ` `// Driver Code``int` `main()``{``     ``int` `N = 6;``     ``cout << minOperation(N);` `    ``return` `0;``}` `// This code is contributed by code_hunt.`

## Java

 `// Java program for the above approach` `class` `GFG {` `    ``// Function to find the minimum number``    ``// of operations required to make the``    ``// array elements equal``    ``public` `static` `int` `minOperation(``int` `N)``    ``{``        ``// If the value of N is even``        ``if` `(N % ``2` `== ``0``) {` `            ``// Return the value``            ``return` `(N / ``2``) * (N / ``2``);``        ``}` `        ``// Otherwise, N is odd``        ``int` `k = (N - ``1``) / ``2``;` `        ``// Return the value``        ``return` `k * (k + ``1``);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `N = ``6``;``        ``System.out.println(``            ``minOperation(N));``    ``}``}`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG{` `// Function to find the minimum number``// of operations required to make the``// array elements equal``public` `static` `int` `minOperation(``int` `N)``{``    ` `    ``// If the value of N is even``    ``if` `(N % 2 == 0)``    ``{``        ` `        ``// Return the value``        ``return` `(N / 2) * (N / 2);``    ``}` `    ``// Otherwise, N is odd``    ``int` `k = (N - 1) / 2;` `    ``// Return the value``    ``return` `k * (k + 1);``}` `// Driver code``static` `void` `Main()``{``    ``int` `N = 6;``    ` `    ``Console.WriteLine(minOperation(N));``}``}` `// This code is contributed by abhinavjain194`

## Python3

 `# Python3 program for the above approach` `# Function to find the minimum number``# of operations required to make the``# array elements equal``def` `minOperation(N) :``    ` `    ``# If the value of N is even``    ``if` `(N ``%` `2` `=``=` `0``) :``  ` `        ``# Return the value``        ``return` `(N ``/` `2``) ``*` `(N ``/` `2``)``          ` `    ``# Otherwise, N is odd``    ``k ``=` `(N ``-` `1``) ``/` `2``  ` `    ``# Return the value``    ``return` `(k ``*` `(k ``+` `1``))``        ` `# Driver Code` `N ``=` `6``print``(``int``(minOperation(N)))` `# This code is contributed by souravghosh0416.`

## Javascript

 ``
Output:
`9`

Time Complexity: O(1)
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