Skip to content
Related Articles

Related Articles

Improve Article

Minimum time to reach a point with +t and -t moves at time t

  • Difficulty Level : Easy
  • Last Updated : 21 May, 2021

Given a positive coordinate ‘X’ and you are at coordinate ‘0’, the task is to find the minimum time required to get to coordinate ‘X’ with the following move : 
At time ‘t’, you can either stay at the same position or take a jump of length exactly ‘t’ either to the left or to the right. In other words, you can be at coordinate ‘x – t’, ‘x’ or ‘x + t’ at time ‘t’ where ‘x’ is the current position.
Examples: 
 

Input: 6
Output: 3
At time 1, jump from x = 0 to x = 1 (x = x + 1)
At time 2, jump from x = 1 to x = 3 (x = x + 2)
At time 3, jump from x = 3 to x = 6 (x = x + 3)
So, minimum required time is 3.

Input: 9
Output: 4
At time 1, do not jump i.e x = 0 
At time 2, jump from x = 0 to x = 2 (x = x + 2)
At time 3, jump from x = 2 to x = 5 (x = x + 3)
At time 4, jump from x = 5 to x = 9 (x = x + 4)
So, minimum required time is 4.

 

Approach: The following greedy strategy works: 
We just find the minimum ‘t’ such that 1 + 2 + 3 + … + t >= X. 
 

  • If (t * (t + 1)) / 2 = X then answer is ‘t’.
  • Else if (t * (t + 1)) / 2 > X, then we find (t * (t + 1)) / 2 – X and remove this number from the sequence [1, 2, 3, …, t]. The resulting sequence sums up to ‘X’.

Below is the implementation of the above approach: 
 

C++




// C++ implementation of the above approach
 
#include <iostream>
 
using namespace std;
 
   // returns the minimum time
    // required to reach 'X'
    long cal_minimum_time(long X)
    {
 
        // Stores the minimum time
        long t = 0;
        long sum = 0;
 
        while (sum < X) {
 
            // increment 't' by 1
            t++;
 
            // update the sum
            sum = sum + t;
        }
 
        return t;
    }
 
// Driver code
int main()
{
        long n = 6;
        long ans = cal_minimum_time(n);
        cout << "The minimum time required is : " << ans ;
 
   return 0;
    
   // This code is contributed by ANKITRAI1
}

Java




// Java implementation of the above approach
class GFG {
 
    // returns the minimum time
    // required to reach 'X'
    static long cal_minimum_time(long X)
    {
 
        // Stores the minimum time
        long t = 0;
        long sum = 0;
 
        while (sum < X) {
 
            // increment 't' by 1
            t++;
 
            // update the sum
            sum = sum + t;
        }
 
        return t;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        long n = 6;
        long ans = cal_minimum_time(n);
        System.out.println("The minimum time required is : " + ans);
    }
}

Python3




# Python 3 implementation of the
# above approach
 
# returns the minimum time
# required to reach 'X'
def cal_minimum_time(X):
 
    # Stores the minimum time
    t = 0
    sum = 0
 
    while (sum < X):
         
        # increment 't' by 1
        t = t + 1
         
        # update the sum
        sum = sum + t;
     
    return t;
 
# Driver code
if __name__ == '__main__':
    n = 6
    ans = cal_minimum_time(n)
    print("The minimum time required is :", ans)
     
# This code is contributed By
# Surendra_Gangwar

C#




// C#  implementation of the above approach
using System;
 
public class GFG{
     
    // returns the minimum time
    // required to reach 'X'
    static long cal_minimum_time(long X)
    {
 
        // Stores the minimum time
        long t = 0;
        long sum = 0;
 
        while (sum < X) {
 
            // increment 't' by 1
            t++;
 
            // update the sum
            sum = sum + t;
        }
 
        return t;
    }
 
    // Driver code
    static public void Main (){
        long n = 6;
        long ans = cal_minimum_time(n);
        Console.WriteLine("The minimum time required is : " + ans);
    }
}

PHP




<?php
// PHP implementation of the
// above approach
 
// returns the minimum time
// required to reach 'X'
function cal_minimum_time($X)
{
    // Stores the minimum time
    $t = 0;
    $sum = 0;
 
    while ($sum < $X)
    {
 
        // increment 't' by 1
        $t++;
 
        // update the sum
        $sum = $sum + $t;
    }
 
    return $t;
}
 
// Driver code
$n = 6;
$ans = cal_minimum_time($n);
echo "The minimum time required is : " . $ans;
 
// This code is contributed
// by ChitraNayal
?>

Javascript




<script>
 
// JavaScript implementation of the above approach
 
    // returns the minimum time
    // required to reach 'X'
    function cal_minimum_time(X)
    {
   
        // Stores the minimum time
        let t = 0;
        let sum = 0;
   
        while (sum < X) {
   
            // increment 't' by 1
            t++;
   
            // update the sum
            sum = sum + t;
        }
   
        return t;
    }
 
// driver code
 
  let n = 6;
  let ans = cal_minimum_time(n);
  document.write("The minimum time required is : " + ans);
   
</script>
Output: 
The minimum time required is : 3

 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :