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.

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to find minimum moves to 
// reach target if we can move i steps in
// i-th move.
#include <iostream>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python 3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program to find  
// minimum moves to reach
// target if we can move i
// steps in i-th move.
  
function 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++;
            $sum += $step;
          }
    return $step;
}
  
// Driver code
$target = 5;
echo reachTarget($target);
  
// This code is contributed by anuj_67.
?>

chevron_right



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 :


9


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