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

My Personal Notes arrow_drop_up