Incremento porcentual en el volumen del paralelepípedo si la longitud, la anchura y la altura aumentan en porcentajes fijos

Dado un paralelepípedo y tres números enteros L , B y H . Si la longitud del paralelepípedo aumenta en L% , el ancho aumenta en B% por ciento y la altura aumenta en H% por ciento. La tarea es encontrar el porcentaje de aumento en el volumen del cuboide.
Ejemplos: 
 

Entrada: L = 50, B = 20, H = 10 
Salida: 98 %
Entrada: L = 10, B = 20, H = 30 
Salida: 71,6 % 
 

Aproximación: suponga que la longitud, el ancho y la altura originales del paralelepípedo sean l , b y h respectivamente. Ahora, la longitud aumentada será (l + ((L * l) / 100)) es decir , longitud aumentada = l * (1 + (L / 100)) . Del mismo modo, el ancho y la altura aumentados aumentaránAncho = b * (1 + (B / 100)) y aumentaránAltura = h * (1 + (H / 100)) . 
Ahora, calcule originalVol = l * b * h y aumentadoVol = aumento de longitud * aumento de ancho * aumento de altura . 
Y, el aumento porcentual se puede encontrar como ((increasedVol – originalVol) / originalVol) * 100 
 

(((l * (1 + (L / 100)) * segundo * (1 + (B / 100)) h * (1 + (H / 100))) – (l * b * h)) / (l * b * h)) * 100 
((l * b * h * (((1 + (L / 100)) * (1 + (B / 100)) * (H / 100)) – 1)) / ( l * b * h)) * 100 
(((1 + (L / 100)) * (1 + (B / 100)) * (1 + (H / 100))) – 1) * 100 
 

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

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the percentage increase
// in the volume of the cuboid
double increaseInVol(double l, double b, double h)
{
    double percentInc = (1 + (l / 100))
                        * (1 + (b / 100))
                        * (1 + (h / 100));
    percentInc -= 1;
    percentInc *= 100;
 
    return percentInc;
}
 
// Driver code
int main()
{
    double l = 50, b = 20, h = 10;
    cout << increaseInVol(l, b, h) << "%";
 
    return 0;
}

// Java implementation of the approach
class GFG
{
     
// Function to return the percentage increase
// in the volume of the cuboid
static double increaseInVol(double l,  
                            double b,
                            double h)
{
    double percentInc = (1 + (l / 100)) *
                        (1 + (b / 100)) *
                        (1 + (h / 100));
    percentInc -= 1;
    percentInc *= 100;
 
    return percentInc;
}
 
// Driver code
public static void main(String[] args)
{
    double l = 50, b = 20, h = 10;
    System.out.println(increaseInVol(l, b, h) + "%");
}
}
 
// This code is contributed by Code_Mech

# Python3 implementation of the approach
 
# Function to return the percentage increase
# in the volume of the cuboid
def increaseInVol(l, b, h):
    percentInc = ((1 + (l / 100)) *
                  (1 + (b / 100)) *
                  (1 + (h / 100)))
    percentInc -= 1
    percentInc *= 100
 
    return percentInc
 
# Driver code
l = 50
b = 20
h = 10
print(increaseInVol(l, b, h), "%")
 
# This code is contributed by Mohit Kumar

// C# implementation of the approach
using System;
 
class GFG
{
     
// Function to return the percentage increase
// in the volume of the cuboid
static double increaseInVol(double l,
                            double b,
                            double h)
{
    double percentInc = (1 + (l / 100)) *
                        (1 + (b / 100)) *
                        (1 + (h / 100));
    percentInc -= 1;
    percentInc *= 100;
 
    return percentInc;
}
 
// Driver code
public static void Main()
{
    double l = 50, b = 20, h = 10;
    Console.WriteLine(increaseInVol(l, b, h) + "%");
}
}
 
// This code is contributed by Code_Mech

<script>
 
// Javascript implementation of the approach
 
// Function to return the percentage increase
// in the volume of the cuboid
function increaseInVol(l, b, h)
{
    let percentInc = (1 + (l / 100))
                        * (1 + (b / 100))
                        * (1 + (h / 100));
    percentInc -= 1;
    percentInc *= 100;
 
    return percentInc;
}
 
// Driver code
    let l = 50, b = 20, h = 10;
    document.write(increaseInVol(l, b, h) + "%");
 
</script>

98%

Tiempo Complejidad: O(1)
Espacio Auxiliar: O(1)