Open in App
Not now

# Find minimum moves to reach target on an infinite line

• Difficulty Level : Hard
• Last Updated : 25 Aug, 2022

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.```

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.

Example: if the target is 2 then, the number of steps should be 3. Lets see how we get that,

1-2+3=2 ( if we start from 0 and move 1 step forward and then 2 steps backward (we land on -1) and further if take 3 steps forward we land on 2.)

1-2+3 can also be written as (1+2+3) -2*(2).

that means if we take the ith move backward then the new sum will become (sum – 2i).

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

 ``

## Javascript

 ``

Output:

`5`

Time Complexity: O(n), where n is the number of steps
Auxiliary Space: O(1), since no extra space has been taken.

Please suggest if someone has a better solution which is more efficient in terms of space and time.