You are given an **even** integer `n`

. You initially have a permutation `perm`

of size `n`

where `perm[i] == i`

**(0-indexed)**.

In one operation, you will create a new array `arr`

, and for each `i`

:

- If
`i % 2 == 0`

, then`arr[i] = perm[i / 2]`

. - If
`i % 2 == 1`

, then`arr[i] = perm[n / 2 + (i - 1) / 2]`

.

You will then assign `arr`

to `perm`

.

Return *the minimum non-zero number of operations you need to perform on *

`perm`

**Example 1:**

Input:n = 2Output:1Explanation:perm = [0,1] initially. After the 1^{st}operation, perm = [0,1] So it takes only 1 operation.

**Example 2:**

Input:n = 4Output:2Explanation:perm = [0,1,2,3] initially. After the 1^{st}operation, perm = [0,2,1,3] After the 2^{nd}operation, perm = [0,1,2,3] So it takes only 2 operations.

**Example 3:**

Input:n = 6Output:4

**Constraints:**

`2 <= n <= 1000`

`n`

is even.

```
struct Solution;
impl Solution {
fn reinitialize_permutation(n: i32) -> i32 {
if n == 2 {
return 1;
}
let mut res = 0;
let mut i = 1;
while res == 0 || i != 1 {
if i % 2 == 0 {
i /= 2;
} else {
i = (n - 1 + i) / 2;
}
res += 1;
}
res
}
}
#[test]
fn test() {
let n = 2;
let res = 1;
assert_eq!(Solution::reinitialize_permutation(n), res);
let n = 4;
let res = 2;
assert_eq!(Solution::reinitialize_permutation(n), res);
let n = 6;
let res = 4;
assert_eq!(Solution::reinitialize_permutation(n), res);
}
```