Tiempo que tardan dos personas en encontrarse en una pista circular

Posted on by Rudeus Greyrat

Dados los números enteros L , S1 y S2 donde L es la longitud de una pista circular en metros, S1 y S2 son las velocidades de dos personas en kilómetros/hora que se mueven en la misma dirección en la pista dada comenzando desde el mismo punto de partida. La tarea es encontrar lo siguiente: 
 

  • La hora a partir de la cual se encontrarán por primera vez.
  • La hora a la que se van a encontrar en el punto de partida.

Ejemplos: 
 

Entrada: L = 30, S1 = 5, S2 = 2 
Salida: Se cumplió por primera vez después de 10 horas 
Se cumplió en el punto de partida después de 30 horas
Entrada: L = 10, S1 = 1, S2 = 2 
Salida: Se cumplió por primera vez después de 10 horas 
Se cumplió en el punto de partida después de 10 horas 
 

Acercarse: 
 

  • Para calcular la hora en que se encontrarán por primera vez. 
    • En primer lugar, calcule la velocidad relativa, es decir, S1 – S2 .
    • Luego usa la fórmula, Tiempo = Distancia / Velocidad relativa .
  • Para calcular la hora a la que se volverán a encontrar en el punto de partida. 
    • En primer lugar, calcule el tiempo, es decir, T1 y T2 , que representan el tiempo que tardan ambos en cubrir 1 vuelta de pista circular utilizando la fórmula Tiempo = Longitud de la pista / Velocidad .
    • Luego calcule el LCM para saber la hora en que se encontrarán nuevamente en el punto de partida.

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

C++

// C++ implementation of above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the time when both the
// persons will meet at the starting point
int startingPoint(int Length, int Speed1, int Speed2)
{
    int result1 = 0, result2 = 0;
 
    // Time to cover 1 round by both
    int time1 = Length / Speed1;
    int time2 = Length / Speed2;
 
    result1 = __gcd(time1, time2);
 
    // Finding LCM to get the meeting point
    result2 = time1 * time2 / (result1);
 
    return result2;
}
 
// Function to return the time when both
// the persons will meet for the first time
float firstTime(int Length, int Speed1, int Speed2)
{
    float result = 0;
 
    int relativeSpeed = abs(Speed1 - Speed2);
 
    result = ((float)Length / relativeSpeed);
 
    return result;
}
 
// Driver Code
int main()
{
    int L = 30, S1 = 5, S2 = 2;
 
    // Calling function
    float first_Time = firstTime(L, S1, S2);
    int starting_Point = startingPoint(L, S1, S2);
 
    cout << "Met first time after "
         << first_Time << " hrs" << endl;
    cout << "Met at starting point after "
         << starting_Point << " hrs" << endl;
 
    return 0;
}

Java

// Java implementation of above approach
public class GFG {
 
// Function to return the time when both the
// persons will meet at the starting point
    static int startingPoint(int Length, int Speed1, int Speed2) {
        int result1 = 0, result2 = 0;
 
        // Time to cover 1 round by both
        int time1 = Length / Speed1;
        int time2 = Length / Speed2;
 
        result1 = __gcd(time1, time2);
 
        // Finding LCM to get the meeting point
        result2 = time1 * time2 / (result1);
 
        return result2;
    }
 
    static int __gcd(int a, int b) {
        if (b == 0) {
            return a;
        }
        return __gcd(b, a % b);
 
    }
// Function to return the time when both
// the persons will meet for the first time
 
    static float firstTime(int Length, int Speed1, int Speed2) {
        float result = 0;
 
        int relativeSpeed = Math.abs(Speed1 - Speed2);
 
        result = ((float) Length / relativeSpeed);
 
        return result;
    }
 
// Driver Code
    public static void main(String[] args) {
        int L = 30, S1 = 5, S2 = 2;
 
        // Calling function
        float first_Time = firstTime(L, S1, S2);
        int starting_Point = startingPoint(L, S1, S2);
 
        System.out.println("Met first time after "
                + first_Time + " hrs");
        System.out.println("Met at starting point after "
                + starting_Point + " hrs");
 
    }
}

Python3

# Python 3 implementation of
# above approach
 
# import gcd() from math lib
from math import gcd
 
# Function to return the time when both the
# persons will meet at the starting point
def startingPoint(Length, Speed1, Speed2) :
 
    result1 = 0
    result2 = 0
 
    # Time to cover 1 round by both
    time1 = Length // Speed1
    time2 = Length // Speed2
 
    result1 = gcd(time1, time2)
 
    # Finding LCM to get the meeting point
    result2 = time1 * time2 // (result1)
 
    return result2
 
# Function to return the time when both
# the persons will meet for the first time
def firstTime(Length, Speed1, Speed2) :
 
    result = 0
 
    relativeSpeed = abs(Speed1 - Speed2)
 
    result = Length / relativeSpeed
 
    return result
 
# Driver Code
if __name__ == "__main__" :
     
    L = 30
    S1 = 5
    S2 = 2
 
    # Calling function
    first_Time = firstTime(L, S1, S2)
    starting_Point = startingPoint(L, S1, S2)
 
    print("Met first time after", first_Time, "hrs")
    print("Met at starting point after",
                  starting_Point, "hrs")
 
# This code is contributed by Ryuga

C#

// C# implementation of above approach
using System;
 
public class GFG {
  
// Function to return the time when both the
// persons will meet at the starting point
    static int startingPoint(int Length, int Speed1, int Speed2) {
        int result1 = 0, result2 = 0;
  
        // Time to cover 1 round by both
        int time1 = Length / Speed1;
        int time2 = Length / Speed2;
  
        result1 = __gcd(time1, time2);
  
        // Finding LCM to get the meeting point
        result2 = time1 * time2 / (result1);
  
        return result2;
    }
  
    static int __gcd(int a, int b) {
        if (b == 0) {
            return a;
        }
        return __gcd(b, a % b);
  
    }
// Function to return the time when both
// the persons will meet for the first time
  
    static float firstTime(int Length, int Speed1, int Speed2) {
        float result = 0;
  
        int relativeSpeed = Math.Abs(Speed1 - Speed2);
  
        result = ((float) Length / relativeSpeed);
  
        return result;
    }
  
// Driver Code
    public static void Main() {
        int L = 30, S1 = 5, S2 = 2;
  
        // Calling function
        float first_Time = firstTime(L, S1, S2);
        int starting_Point = startingPoint(L, S1, S2);
  
        Console.WriteLine("Met first time after "
                + first_Time + " hrs");
        Console.WriteLine("Met at starting point after "
                + starting_Point + " hrs");
  
    }
}
/*This code is contributed by 29AjayKumar*/

PHP

<?php
// PHP implementation of above approach
 
function gcd ($a, $b)
{
    return $b ? gcd($b, $a % $b) : $a;
}
 
// Function to return the time
// when both the persons will
// meet at the starting point
function startingPoint($Length, $Speed1,
                                $Speed2)
{
    $result1 = 0;
    $result2 = 0;
 
    // Time to cover 1 round by both
    $time1 = $Length / $Speed1;
    $time2 = $Length / $Speed2;
 
    $result1 = gcd($time1, $time2);
 
    // Finding LCM to get the
    // meeting point
    $result2 = $time1 * $time2 / ($result1);
 
    return $result2;
}
 
// Function to return the time when both
// the persons will meet for the first time
function firstTime($Length, $Speed1, $Speed2)
{
    $result = 0;
 
    $relativeSpeed = abs($Speed1 - $Speed2);
 
    $result = ((float)$Length /
                      $relativeSpeed);
 
    return $result;
}
 
// Driver Code
$L = 30;
$S1 = 5;
$S2 = 2;
 
// Calling function
$first_Time = firstTime($L, $S1, $S2);
$starting_Point = startingPoint($L, $S1, $S2);
 
echo "Met first time after ".
    $first_Time ." hrs" ."\n";
echo "Met at starting point after ".
    $starting_Point . " hrs" ."\n";
 
// This code is contributed
// by ChitraNayal
?>

Javascript

<script>
// javascript implementation of above approach
 
    // Function to return the time when both the
    // persons will meet at the starting point
    function startingPoint(Length , Speed1 , Speed2)
    {
        var result1 = 0, result2 = 0;
 
        // Time to cover 1 round by both
        var time1 = Length / Speed1;
        var time2 = Length / Speed2;
 
        result1 = __gcd(time1, time2);
 
        // Finding LCM to get the meeting point
        result2 = time1 * time2 / (result1);
 
        return result2;
    }
 
    function __gcd(a , b)
    {
        if (b == 0)
        {
            return a;
        }
        return __gcd(b, a % b);
 
    }
     
    // Function to return the time when both
    // the persons will meet for the first time
    function firstTime(Length , Speed1 , Speed2)
    {
        var result = 0;
        var relativeSpeed = Math.abs(Speed1 - Speed2);
        result = ( Length / relativeSpeed);
        return result;
    }
 
    // Driver Code   
    var L = 30, S1 = 5, S2 = 2;
 
        // Calling function
        var first_Time = firstTime(L, S1, S2);
        var starting_Point = startingPoint(L, S1, S2);
 
        document.write("Met first time after " + first_Time + " hrs<br/>");
        document.write("Met at starting point after " + starting_Point + " hrs");
 
// This code is contributed by todaysgaurav
</script>
Producción: 

Met first time after 10 hrs
Met at starting point after 30 hrs

 

Complejidad de tiempo: O(log(max(t1,t2)), donde t1, t2 son tiempos correspondientes a distancias y velocidades dadas.

Espacio Auxiliar: O(1), ya que no se ha ocupado ningún espacio extra.

Publicación traducida automáticamente

Artículo escrito por Naman_Garg y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *