You are standing at position `0`

on an infinite number line. There is a goal at position `target`

.

On each move, you can either go left or right. During the *n*-th move (starting from 1), you take *n* steps.

Return the minimum number of steps required to reach the destination.

**Example 1:**

Input:target = 3Output:2Explanation:On the first move we step from 0 to 1. On the second step we step from 1 to 3.

**Example 2:**

Input:target = 2Output:3Explanation:On the first move we step from 0 to 1. On the second move we step from 1 to -1. On the third move we step from -1 to 2.

**Note:**

`target`

will be a non-zero integer in the range `[-10^9, 10^9]`

.```
struct Solution;
impl Solution {
fn reach_number(target: i32) -> i32 {
let target = target.abs();
let n = (((2 * target as i64) as f64 + 0.25).sqrt() - 0.5).ceil() as i32;
let sum = n * (n + 1) / 2;
if sum == target {
n
} else {
let diff = sum - target;
if diff % 2 == 0 {
n
} else {
if n % 2 == 0 {
n + 1
} else {
n + 2
}
}
}
}
}
#[test]
fn test() {
assert_eq!(Solution::reach_number(3), 2);
assert_eq!(Solution::reach_number(2), 3);
assert_eq!(Solution::reach_number(5), 5);
}
```