You have an array `arr`

of length `n`

where `arr[i] = (2 * i) + 1`

for all valid values of `i`

(i.e. `0 <= i < n`

).

In one operation, you can select two indices `x`

and `y`

where `0 <= x, y < n`

and subtract `1`

from `arr[x]`

and add `1`

to `arr[y]`

(i.e. perform `arr[x] -=1 `

and `arr[y] += 1`

). The goal is to make all the elements of the array **equal**. It is **guaranteed** that all the elements of the array can be made equal using some operations.

Given an integer `n`

, the length of the array. Return *the minimum number of operations* needed to make all the elements of arr equal.

**Example 1:**

Input:n = 3Output:2Explanation:arr = [1, 3, 5] First operation choose x = 2 and y = 0, this leads arr to be [2, 3, 4] In the second operation choose x = 2 and y = 0 again, thus arr = [3, 3, 3].

**Example 2:**

Input:n = 6Output:9

**Constraints:**

`1 <= n <= 10^4`

## Solution

### Java Program

```
class Solution {
public int minOperations(int n) {
int min = 1;
int max = 2 * (n - 1) + 1;
int equalNumber = (min + max)/2;
int result = 0;
for(int index = 0; index < (n/2); index++)
{
result += (equalNumber - (2 * index + 1));
}
return result;
}
}
```

## Code walkthrough

```
n = 6, arr = [1, 3, 5, 7, 9, 11]
1st Operation: arr = [
```**2**, 3, 5, 7, 9, **10**];
2nd Operation: arr = [**3**, 3, 5, 7, 9, **9**];
3rd Operation: arr = [3, **4**, 5, 7, **8**, 9];
4th Operation: arr = [**4**, 4, 5, 7, 8, **8**];
5th Operation: arr = [4, **5**, 5, 7, **7**, 8];
6th Operation: arr = [**5**, 5, 5, 7, 7, **7**];
7th Operation: arr = [5, 5, **6**, **6**, 7, 7];
8th Operation: arr = [1,** 6**, 6, 6, **6**, 11];
9th Operation: arr = [**6**, 6, 6, 6, 6, **6**];
Output: 9
From the above operations you can observe one thing that,
min = 1
max = 11
equalNumber = (min + max)/2 = (1 + 11)/2 = 6;
result = (6-1) + (6-3) + (6-5) => 9