Tiempo mínimo para llegar a un punto con movimientos +t y -t en el tiempo t

Dada una coordenada positiva ‘X’ y estás en la coordenada ‘0’, la tarea es encontrar el tiempo mínimo requerido para llegar a la coordenada ‘X’ con el siguiente movimiento: 
En el tiempo ‘t’, puedes quedarte en el mismo posición o dar un salto de longitud exactamente ‘t’ hacia la izquierda o hacia la derecha. En otras palabras, puede estar en la coordenada ‘x – t’, ‘x’ o ‘x + t’ en el tiempo ‘t’ donde ‘x’ es la posición actual.
Ejemplos: 
 

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.

Enfoque: la siguiente estrategia codiciosa funciona: 
simplemente encontramos la ‘t’ mínima tal que 1 + 2 + 3 + … + t >= X. 
 

• Si (t * (t + 1)) / 2 = X entonces la respuesta es ‘t’.
• De lo contrario, si (t * (t + 1)) / 2 > X, entonces encontramos (t * (t + 1)) / 2 – X y eliminamos este número de la secuencia [1, 2, 3, …, t] . La secuencia resultante se suma a ‘X’.

A continuación se muestra la implementación del enfoque anterior: 

// 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 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);
    }
}

# 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#  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 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
?>

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

The minimum time required is : 3

Complejidad de tiempo: O(n)

Espacio Auxiliar: O(1)