Averigüe si el vaso estará vacío o no cuando se dé la tasa de consumo

Dado un cilindro de vidrio con diámetro igual a D centímetros. El nivel inicial de agua en el vaso es igual a H centímetros desde el fondo. Bebes el agua con una velocidad de M mililitros por segundo. Pero si no bebes el agua del vaso, el nivel del agua aumenta en N centímetros por segundo. La tarea es encontrar el tiempo requerido para vaciar el vaso o encontrar si es posible vaciar el vaso o no.
Ejemplos: 
 

Entrada: D = 1, H = 1, M = 1, N = 1 
Salida: 3,65979
Entrada: D = 1, H = 2, M = 3, N = 100 
Salida: -1 
 

Enfoque: Esta es una pregunta de Geometría. Se sabe que el área del vaso es pastel * r ² donde r representa el radio, es decir (D / 2) . Entonces, para encontrar la velocidad a la que se consume el agua por segundo, divida el volumen dado (se sabe que 1 mililitro equivale a 1 centímetro cúbico) con el área. 
Si el valor es menor que la velocidad a la que se vierte el agua en el vaso, si no se bebe, la respuesta será No , de lo contrario, el vaso puede estar vacío. 
Para encontrar el tiempo, divide h / (v / (tarta * r ² ) – e) y ese es el tiempo en que el vaso se vaciará.
A continuación se muestra la implementación del enfoque anterior: 
 

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
double pie = 3.1415926535897;
 
// Function to return the time when
// the glass will be empty
double findsolution(double d, double h,
                    double m, double n)
{
    double k = (4 * m) / (pie * d * d);
 
    // Check the condition when the
    // glass will never be empty
    if (n > k)
        return -1;
 
    // Find the time
    double ans = (h / (k - n));
    return ans;
}
 
// Driver code
int main()
{
    double d = 1, h = 1, m = 1, n = 1;
 
    cout << findsolution(d, h, m, n);
 
    return 0;
}

// Java implementation of the approach
 
class GFG
{
 
static double pie = 3.1415926535897;
 
// Function to return the time when
// the glass will be empty
static double findsolution(double d, double h,
                    double m, double n)
{
    double k = (4 * m) / (pie * d * d);
 
    // Check the condition when the
    // glass will never be empty
    if (n > k)
        return -1;
 
    // Find the time
    double ans = (h / (k - n));
    return ans;
}
 
// Driver code
public static void main(String[] args)
{
    double d = 1, h = 1, m = 1, n = 1;
 
    System.out.printf("%.5f",findsolution(d, h, m, n));
}
}
 
// This code is contributed by 29AjayKumar

# Python3 implementation of the approach
pie = 3.1415926535897
 
# Function to return the time when
# the glass will be empty
def findsolution(d, h, m, n):
 
    k = (4 * m) / (pie * d * d)
 
    # Check the condition when the
    # glass will never be empty
    if (n > k):
        return -1
 
    # Find the time
    ans = (h / (k - n))
    return round(ans, 5)
 
# Driver code
d = 1
h = 1
m = 1
n = 1
 
print(findsolution(d, h, m, n))
 
# This code is contributed by Mohit Kumar

// C# implementation of the approach
using System;
 
class GFG
{
static double pie = 3.1415926535897;
 
// Function to return the time when
// the glass will be empty
static double findsolution(double d, double h,
                           double m, double n)
{
    double k = (4 * m) / (pie * d * d);
 
    // Check the condition when the
    // glass will never be empty
    if (n > k)
        return -1;
 
    // Find the time
    double ans = (h / (k - n));
    return ans;
}
 
// Driver code
public static void Main(String[] args)
{
    double d = 1, h = 1, m = 1, n = 1;
 
    Console.Write("{0:F5}",
            findsolution(d, h, m, n));
}
}
 
// This code is contributed by 29AjayKumar

<script>
 
// JavaScript implementation of the approach
    const pie = 3.1415926535897;
 
    // Function to return the time when
    // the glass will be empty
    function findsolution(d , h , m , n) {
        var k = (4 * m) / (pie * d * d);
 
        // Check the condition when the
        // glass will never be empty
        if (n > k)
            return -1;
 
        // Find the time
        var ans = (h / (k - n));
        return ans;
    }
 
    // Driver code
     
        var d = 1, h = 1, m = 1, n = 1;
 
         document.write(findsolution(d, h, m, n).toFixed(5));
 
// This code contributed by Rajput-Ji
 
</script>

3.65979

Complejidad de tiempo: O(1)

Espacio Auxiliar: O(1)