# Find minimum moves to reach target on an infinite line

Given a target position on infinite number line, i.e -infinity to +infinity. Starting form 0 you have to reach the target by moving as described : In ith move you can take i steps forward or backward. Find the minimum number of moves require to reach the target.

Examples :

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

Input: target = 2
Output: 3
Explanation:
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.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

We have discussed a naive recursive solution in below post.
Minimum steps to reach a destination

If target is negative, we can take it as positive because we start from 0 in symmetrical way.
Idea is to move in one direction as long as possible, this will give minimum moves. Starting at 0 first move takes us to 1, second move takes us to 3 (1+2) position, third move takes us to 6 (1+2+3) position, ans so on; So for finding target we keep on adding moves until we find the nth move such that 1+2+3+…+n>=target. Now if sum (1+2+3+…+n) is equal to target the our job is done, i.e we’ll need n moves to reach target. Now next case where sum is greater than target. Find the difference by how much we are ahead, i.e sum – target. Let the difference be d = sum – target.
If we take the i-th move backward then the new sum will become (sum – 2i), i.e 1+2+3+…-x+x+1…+n. Now if sum-2i = target then our job is done. Since, sum – target = 2i, i.e difference should be even as we will get an integer i flipping which will give the answer. So following cases arise.
Case 1 : Difference is even then answer is n, (because we will always get a move flipping which will lead to target).
Case 2 : Difference is odd, then we take one more step, i.e add n+1 to sum and now again take the difference. If difference is even the n+1 is the answer else we would have to take one more move and this will certainly make the difference even then answer will be n+2.

Explanation : Since difference is odd. Target is either odd or even.
case 1: n is even (1+2+3+…+n) then adding n+1 makes the difference even.
case 2: n is odd then adding n+1 doesn’t makes difference even so we would have to take one more move, so n+2.

Example:
target = 5.
we keep on taking moves until we reach target or we just cross it.
sum = 1 + 2 + 3 = 6 > 5, step = 3.
Difference = 6 – 5 = 1. Since the difference is an odd value, we will not reach the target by flipping any move from +i to -i. So we increase our step. We need to increase step by 2 to get an even difference (since n is odd and target is also odd). Now that we have an even difference, we can simply switch any move to the left (i.e. change + to -) as long as the summation of the changed value equals to half of the difference. We can switch 1 and 4 or 2 and 3 or 5.

## C++

 `// CPP program to find minimum moves to  ` `// reach target if we can move i steps in ` `// i-th move. ` `#include ` `using` `namespace` `std; ` ` `  `int` `reachTarget(``int` `target) ` `{ ` `    ``// Handling negatives by symmetry ` `    ``target = ``abs``(target); ` `     `  `    ``// Keep moving while sum is smaller or difference ` `    ``// is odd. ` `    ``int` `sum = 0, step = 0; ` `    ``while` `(sum < target || (sum - target) % 2 != 0) { ` `        ``step++; ` `        ``sum += step; ` `    ``} ` `    ``return` `step; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `target = 5; ` `    ``cout << reachTarget(target); ` `    ``return` `0; ` `} `

## Java

 `// Java program to find minimum   ` `//moves to reach target if we can ` `// move i steps in i-th move. ` `import` `java.io.*; ` `import` `java.math.*; ` ` `  `class` `GFG { ` `     `  `    ``static` `int` `reachTarget(``int` `target) ` `    ``{ ` `        ``// Handling negatives by symmetry ` `        ``target = Math.abs(target); ` `         `  `        ``// Keep moving while sum is smaller ` `        ``// or difference is odd. ` `        ``int` `sum = ``0``, step = ``0``; ` `         `  `        ``while` `(sum < target || (sum - target) % ``2` `                                        ``!= ``0``) { ` `            ``step++; ` `            ``sum += step; ` `        ``} ` `        ``return` `step; ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `       ``int` `target = ``5``; ` `       ``System.out.println(reachTarget(target)); ` `    ``} ` `} ` ` `  `// This code is contributed by Nikita tiwari. `

## Python 3

 `# Python 3 program to find minimum   ` `# moves to reach target if we can  ` `# move i steps in i-th move. ` ` `  ` `  `def` `reachTarget(target) : ` ` `  `    ``# Handling negatives by symmetry ` `    ``target ``=` `abs``(target) ` `     `  `    ``# Keep moving while sum is  ` `    ``# smaller or difference is odd. ` `    ``sum` `=` `0` `    ``step ``=` `0` `    ``while` `(``sum` `< target ``or` `(``sum` `-` `target) ``%`  `                                  ``2` `!``=` `0``) : ` `        ``step ``=` `step ``+` `1` `        ``sum` `=` `sum` `+` `step ` `     `  `    ``return` `step ` `     `  ` `  `# Driver code ` `target ``=` `5` `print``(reachTarget(target)) ` ` `  ` `  `# This code is contributed by Nikita Tiwari `

## C#

 `// C# program to find minimum  ` `//moves to reach target if we can ` `// move i steps in i-th move. ` `using` `System; ` ` `  `class` `GFG { ` `     `  `    ``static` `int` `reachTarget(``int` `target) ` `    ``{ ` `        ``// Handling negatives by symmetry ` `        ``target = Math.Abs(target); ` `         `  `        ``// Keep moving while sum is smaller ` `        ``// or difference is odd. ` `        ``int` `sum = 0, step = 0; ` `         `  `        ``while` `(sum < target ||  ` `              ``(sum - target) % 2!= 0)  ` `        ``{ ` `            ``step++; ` `            ``sum += step; ` `        ``} ` `        ``return` `step; ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `    ``int` `target = 5; ` `    ``Console.WriteLine(reachTarget(target)); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m. `

## PHP

 ` `

Output :

```5
```

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : vt_m

Article Tags :
Practice Tags :

13

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.