在时间t达到+ t和-t移动的最小时间

给定正坐标“ X”，并且您位于坐标“ 0”，任务是找到通过以下动作获得坐标“ X”所需的最短时间：
在时间“ t”，您可以停留在同一位置，也可以向左或向右跳一个长度为“ t”的长度。换句话说，您可以在时间“ t”处位于坐标“ x – t”，“ x”或“ x + t”，其中“ x”是当前位置。

例子：

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.

方法：以下贪婪策略有效：
我们只是找到最小值“ t”，使得1 + 2 + 3 + ... + t >= X

• 如果(t * (t + 1)) / 2 = X则答案为’t’。
• 否则，如果(t * (t + 1)) / 2 > X ，则我们找到(t * (t + 1)) / 2 – X并将该数字从序列[1, 2, 3, ..., t] 。所得序列的总和为“ X”。

下面是上述方法的实现：

C++

// C++ implementation of the above approach
  
#include 
  
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); 
    } 
}

输出：

The minimum time required is : 3