6

#PlatziCodingChallenge - Calculadora de volúmenes

Demian
demian
48320

15. Calculadora de volúmenes, el usuario debe elegir entre Cilindro, Cubo y Esfera

Las matemáticas son base fundamental de la lógica y programación, por eso es importante practicarlas constantemente. Un cilindro es un cuerpo geométrico que requiere de varias fórmulas, aplícalas en un programa que reciba datos como su altura y radio de las bases para mostrar el resultado acotado a un decimal.

Reglas del reto

Escribe tu comentario
+ 2
Ordenar por:
3
10710Puntos

My solution in Python

import math

defcylinder(radius, height):
    area = math.pi * (radius ** 2)
    return area * height


defcube(side):return side ** 3defsphere(radius):return (4 * (math.pi) * (radius**3)) / 3defmain():
    print("Volume Calculator".center(50))
    print("*" * 50)

    figures = {
        1: "Cylinder",
        2: "Cube",
        3: "Sphere"
    }

    for key, ftype in figures.items():
        print(f"{key}. {ftype}")

    option = int(input("Select an option: "))
    print("*" * 50)
    if option in figures:
        if option == 1:
            radius = float(input("Insert the radius: "))
            height = float(input("Insert the height: "))
            volume = cylinder(radius, height)
        elif option == 2:
            side = float(input("Insert the size of one side: "))
            volume = cube(side)
        elif option == 3:
            radius = float(input("Insert the radius: "))
            volume = sphere(radius)
        print(f"The volume for a {figures[option]} is {round(volume, 1)}")
    else:
        print("Bad Option")
    

if __name__ == "__main__":
    main()
2
19943Puntos

Calculadora de Volumenes en Python y en JavaScript

#Calculadora de Volumenes en Pythonfrom math import pi

classcylinder():def__init__(self):
        self.height = float(input('Introduzca la altura del cilindro: '))
        self.radio = float(input('Introduzca el radio de las bases del cilindro: '))
    defgetVolume(self):return pi * self.radio**2 * self.height

classcube():def__init__(self):
        self.side = float(input('Introduzca el lado del cubo: '))
    defgetVolume(self):return self.side**3classsphere():def__init__(self):
        self.radio = float(input('Introduzca el radio de la esfera: '))
    defgetVolume(self):return (4/3) * pi * self.radio**3

opcion = input('¿Cuál quiere? Cilindro, Cubo o Esfera: ').lower()
if opcion == 'cilindro':
    cilindro = cylinder()
    print('El volumen del cilindro es: {}'.format(round(cilindro.getVolume(), 2)))
elif opcion == 'cubo':
    cubo = cube()
    print('El volumen del cubo es: {}'.format(round(cubo.getVolume(), 2)))
elif opcion == 'esfera':
    esfera = sphere()
    print('El volumen de la esfera es: {}'.format(round(esfera.getVolume(), 2)))
else:
    print('No conozco esa figura')
//Calculadora de Volumenes en JavaScriptclasscylinder{
    constructor() {
        this.height = parseFloat(prompt('Introduzca la altura del cilindro'))
        this.radio = parseFloat(prompt('Introduzca el radio del cilindro'))
    }
    getVolume() {
        returnMath.PI * Math.pow(this.radio, 2) * this.height
    }
}
classcube{
    constructor() {
        this.side = parseFloat(prompt('Introduzca el lado del cubo'))
    }
    getVolume() {
        returnMath.pow(this.side, 3)
    }
}
classsphere{
    constructor() {
        this.radio = parseFloat(prompt('Introduzca el radio de la esfera'))
    }
    getVolume() {
        return (4/3) * Math.PI * Math.pow(this.radio, 3)
    }
}

const opcion = prompt('¿Cuál quiere? Cilindro, Cubo o Esfera').toLowerCase()
switch (opcion) {
    case'cilindro':
        const cilindro = new cylinder()
        alert(`El volumen del cilindro es ${cilindro.getVolume().toFixed(2)}`)
        breakcase'cubo':
        const cubo = new cube()
        alert(`El volumen del cubo es ${cubo.getVolume().toFixed(2)}`)
        breakcase'esfera':
        const esfera = new sphere()
        alert(`El volumen de la esfera es ${esfera.getVolume().toFixed(2)}`)
}
1
7078Puntos
#include<iostream>#include<cmath>usingnamespacestd;

intmain(){
     float altura = 0, radio = 0, volumen = 0;
    char opcion = ' ';

    cout << "Calculadora de volumenes" << endl;

    cout << "Elige que deseas calcular (a. Cilindro, b. Cubo, c. Esfera): ";
    cin >> opcion;

    if(opcion == 'a')
    {
        cout << "Ingresa la altura del cilindro: ";
        cin >> altura;
        cout << "Ingresa el radio del cilindro: ";
        cin >> radio;

        volumen = M_PI * (radio * radio) * altura;
        cout << "El volumen del cilindro es: " << volumen;
    }
    elseif(opcion == 'b')
    {
        cout << "Ingresa la altura del cubo: ";
        cin >> altura;

        volumen = altura * altura * altura;
        cout << "El volumen del cubo es: " << volumen;
    }
    elseif(opcion == 'c')
    {
        cout << "Ingresa el radio de la esfera: ";
        cin >> radio;

        volumen = (4 * M_PI * (radio * radio * radio)) / 3;
        cout << "El volumen del cubo es: " << volumen;
    }
    else
    {
        cout << "No juege con el programa";
    }

    return0;
}
1
2345Puntos

Calculadora de volúmenes en JS

var opVol = parseInt(prompt('Para calcular volumen selecciona una figura:\nEsfera --> 1\nCilindro --> 2\nCubo -->3'));
switch(opVol){
    case1: 
        var nombreFigura = 'esfera'var r = parseInt(prompt('Favor digite el valor del radio(r) en cms3: '));
        var V = ((4/3)*Math.PI*(r**3))
        var restoMsj = `es ${V.toFixed(1)} cms3`break;
    case2:
        var nombreFigura = 'cilindro'var h = parseInt(prompt('Favor digite el valor de la altura(h) en cms3: '));
        var r = parseInt(prompt('Favor digite el valor del radio(r) en cms3: '));
        var V = (h*Math.PI*(r**2))
        var restoMsj = `es ${V.toFixed(1)} cms3`break;
    case3:
        var nombreFigura = 'cubo'var a = parseInt(prompt('Favor digite el valor de la arista(a) en cms3: '));
        var V = (a**3)
        var restoMsj = `es ${V.toFixed(1)} cms3`break;
    default:
        // defaultvar nombreFigura = 'no es un valido por que no seleccionó una opción correcta.'var restoMsj = ` `
}
alert(`El volumen de la figura ${nombreFigura}${restoMsj}`)
1
26494Puntos

Resuelto en Python. 😃

from math import pi

defvolumen_cilindro(r, h):return pi*(r**2)*h


defvolumen_cubo(l):return l**3defvolumen_esfera(r):return (pi*(r**3)*4)/3defrun():
    menu = """Calculadora de volúmenes: Cubo, esfera y cilindro:
    [C]ubo
    [E]sfera
    [Ci]lindro

    Inserta las letras de la figura a calcular: """

    opcion = input(menu)
    opcion = opcion.lower()    

    if opcion == 'c':
        figura = 'cubo'
        lado = float(input('\n\nInserta el tamaño del lado del cubo: '))
        volumen = volumen_cubo(lado)
    elif opcion == 'e':
        figura = 'esfera'
        radio = float(input('\n\nInserta el tamaño del radio de la espera: '))
        volumen = volumen_esfera(radio)
    elif opcion == 'ci':
        figura = 'cilindro'
        radio = float(input('\n\nInserta el tamaño del radio del cilindro: '))
        altura = float(input('\n\nInserta el tamaño de la altura del cilindro: '))
        volumen = volumen_cilindro(radio, altura)
        
    volumen = round(volumen, 1)
    print(f'\nEl volumen de la figura {figura} es {volumen} unidades cúbicas.')


if __name__ == "__main__":
    run()
1

En python 😃

import math

defcilindro(radio,altura,figura):
    area=math.pi*radio**2
    volumen=area*altura
    run(volumen,figura)
defcubo(lado,figura):
    volumen=lado**3
    run(volumen,figura)
defesfera(radio,figura):
    volumen=4/3*(math.pi)*(radio**3)
    run(volumen,figura)
defrun(volumen,figura):
    volumen=round(volumen,1)
    print(f'El volumen de tu {figura} es : {volumen}')

if __name__ == "__main__":
    menu=''' Bienvenido a tu calculadora de volumenes, Ingrese un número segun su necesidad
        1.- Calcular volumen de cilindro
        2.- Calcular de cubo
        3.- Calcular de esfera'''
    print(menu)
    
    opcion=int(input('Escoge tu calculadora: '))
    
    if opcion == 1or opcion==3:
        radio=float(input(f'Ingresa el radio: '))
        if opcion==1:
            figura='cilindro'
            altura=float(input('Ingresa la altura de tu cilindro: '))
            cilindro(radio,altura,figura)        
        else:
            figura='esfera'
            esfera(radio,figura)
    elif opcion==2:
        figura='cubo'
        lado=float(input('Ingresa la longitud del lado de tu cubo: '))
        cubo(lado,figura)
    else:
        print('Introduce una opcion correcta: ')```
1
8040Puntos
<let chooseFigure = prompt(
  "Calculate volume of these shapes: K=cube,C=cylinder,S=sphere"
).toUpperCase();
if (chooseFigure === "K") {
  let side1 = parseInt(prompt("What measure has the side of cube?"));
  let volumeCube = side1 ** (3);
  console.log(`Volume of cube is: ${volumeCube.toFixed(1)} cm3`);
}
if (chooseFigure === "C") {
  let heightCylinder = parseFloat(prompt("What's the height of cylinder?"));
  let radioCylinder = parseFloat(prompt("What's the radio of cylinder?"));
  const pi = 3.14159;
  let volumeCylinder = pi * (radioCylinder ** 2)* heightCylinder;
  console.log(`Volume of cylinder is: ${volumeCylinder.toFixed(1)} cm3`);
}
if (chooseFigure === "S") {
  let radioSphere = parseFloat(prompt("What's the radio of sphere?"));
  const pi = 3.14159;
  let volumeSphere = (4 / 3) * pi * (radioSphere ** 3);
  console.log(`Volume of sphere is: ${volumeSphere.toFixed(1)} cm3`);
}
>
1
13595Puntos

En Java:

public class VolumeCalculator {
    public static void run(){
        Scanner scan = new Scanner(System.in);
        final double PI = Math.PI;double height = 0;double radius = 0;double volume = 0;System.out.println("Select the type of body: 1. Cylinder \n 2. Cube \n 3. Sphere \n 4. Exit");int selection = scan.nextInt();do {
        switch (selection){
            case1:
                System.out.println("Height:");
                height = scan.nextDouble();System.out.println("Radius:");
                radius = scan.nextDouble();
                volume = PI * (radius * radius) * height;System.out.println("Volume = " + volume);break;case2:
                System.out.println("Height:");
                height = scan.nextDouble();
                volume = Math.pow(height, 3);System.out.println("Volume = " + volume);break;case3:
                System.out.println("Radius:");
                radius = scan.nextDouble();
                volume = (4/3) * PI * Math.pow(radius, 3);System.out.println("Volume = " + volume);break;case4:
                break;default:
                System.out.println("That is not a valid option");break;
        }
        }while (selection != 4);
    }
}
1

En Python:

"""Programa para calcular el volumen de un CILINDRO, CUBO o ESFERA recibiendo los parámetros necesarios según la figura escogida, redondeando el resultado a un decimal.
Program to calculate the volume of a CYLINDER, CUBE or SPHERE receiving the necessary parameters according to the chosen figure, rounding the result to a decimal.."""from math import pi

classsphere:def__init__(self, radius):
        self.radius = radius
    defget_volume(self):
        volume = 4*pi*(self.radius**3)/3return volume

classcube:def__init__(self, side):
        self.side = side
    defget_volume(self):
        volume = self.side**3return volume

classcylinder:def__init__(self, height, radius):
        self.height = height
        self.radius = radius
    defget_volume(self):
        volume = pi*(self.radius**2)*self.height
        return volume

defask_numeric_entry(element, figure):try:
        whileTrue:
            entry = float(input('Please insert {} value of your {}: ' .format(element, figure)))
            if entry > 0:
                return entry
            else:
                entry = int('a')
    except:
        whileTrue:
            try:
                entry = float(input('Invalid entry. Please insert a positive numeric value: '))
                if entry > 0:
                    return entry
            except:
                passif __name__ == "__main__":
    #print(ask_numeric_entry('radius', 'cylinder'))
    print('VOLUME CALCULATOR!!!')
    print('Please enter the respective number of the figure you want to calculate to select it:')
    print('\n 1. Cube.\n 2. Cylinder.\n 3. Sphere.')
    figure_number = input('\nFigure number: ')
    
    whilenot (figure_number in ('1','2','3')):
        figure_number = input('\nPlease insert a valid option (1, 2, 3): ')
    
    if figure_number == '1':
        print('You have selected CUBE!')
        side = ask_numeric_entry('SIDE', 'CUBE')
        figure = 'CUBE'
        cube = cube(side)
        volume = cube.get_volume()
        
    elif figure_number == '2':
        print('You have selected CYLINDER!')
        radius = ask_numeric_entry('RADIUS', 'CYLINDER')
        height = ask_numeric_entry('HEIGHT', 'CYLINDER')
        figure = 'CYLINDER'
        cylinder = cylinder(height, radius)
        volume = cylinder.get_volume()
        
    else:
        print('You have selected SPHERE!')
        radius = ask_numeric_entry('RADIUS', 'SPHERE')
        figure = 'SPHERE'
        sphere = sphere(radius)
        volume = sphere.get_volume()

    print('The volume of your {} is {} cubic units.' .format(figure, round(volume, 1)))
1
14394Puntos
const findCubeVolume = () =>{
    const leenght = parseFloat(prompt('Ingresa el largo: '));
    const widht = parseFloat(prompt('Ingresa el ancho: '));
    const height = parseFloat(prompt('Ingresa la altura'));

    const volume = leenght * widht * height;
    console.log(`El volumen del cubo es: ${volume.toFixed(2)}`)
}

const findCylinderVolume = () =>{
    const baseArea = parseFloat(prompt('Ingresa el area de la base: '));
    const height = parseFloat(prompt('Ingresa la altura: '))

    const volume = baseArea * height;
    console.log(`El volumen del cilindro es: ${volume.toFixed(2)}`)
}

const findSphereVolume = () =>{
    const ratio = parseFloat(prompt('Ingresa el radio de la esfera'))
    const pi = 3.1416const cubeRatio = ratio**3;

    const volume = (4 * pi * cubeRatio)/3console.log(`El volumen de la esfera es: ${volume.toFixed(2)}`)
}


let devChoose = parseInt(prompt('Escoje: 1.Cubo/2.Cilindro/3.Esfera'));

switch(devChoose){
    case1:
        findCubeVolume();
        break;
    case2:
        findCylinderVolume();
        break;
    case3:
        findSphereVolume();
        break;
}
1
6327Puntos

Calculadora de volúmenes en Java ☕️ ☕️ 😃

public class CalculadoraVolumenes {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        DecimalFormat df = new DecimalFormat("#.0"); //para que muestre solo 1 decimalSystem.out.println("Calculadora de vólumenes :) \n1-cilcindro 2-cubo 3-esfera");int opcion = scanner.nextInt();double volumen = 0;double radio = 0;double altura = 0;double lado = 0;switch (opcion) {
            case1: //cilindroSystem.out.println("Ingresa la altura");
                altura = scanner.nextDouble();System.out.println("Ingresa el radio de una de sus bases");
                radio = scanner.nextDouble();
                volumen = Math.PI * Math.pow(radio, 2) * altura;System.out.println("El volumen del cilindro es: " + df.format(volumen));break;case2: //cuboSystem.out.println("Ingresa la medida de un lado");
                lado = scanner.nextInt();
                volumen = Math.pow(lado, 3);System.out.println("El volumen del cubo es: " + df.format(volumen));break;case3: //esferaSystem.out.println("Ingresa el radio de la esfera:");
                radio = scanner.nextDouble();
                volumen = (Math.PI * 4) * Math.pow(radio, 3) / 3;System.out.println("El volumen de la esfera es: " + df.format(volumen));break;default: //cualquier otra opciónSystem.out.println("Opción no válida :(");break;
        }
    }
}

Resultado de la ejecución (cilindro)

Resultado de la ejecución (cubo)

Resultado de la ejecución (esfera)

1
7689Puntos

Muy bueno

<!DOCTYPE html><htmllang="en"><head><metacharset="UTF-8"><metaname="viewport"content="width=device-width, initial-scale=1.0"><title>Volumen del Cilindro</title></head><style>
  * {
    margin: 0;
  }

  .contenedor {
    display: flex;
    flex-direction: column;
    align-items: center;
    justify-content: center;
    height: 100vh;
  }

  .section {
    margin: 2rem;
  }

  .datos {
    display: inherit;
    flex-flow: row;
    margin-bottom: 30px;
    font-size: 18px;
  }

  .inputsinput {
    display: flex;
    flex-direction: column;
    margin: 2rem;
  }

  .btn {
    border: 2px solid black;
    border-radius: 6px;
    cursor: pointer;
    font-size: 24px;
  }

  .resultado {
    margin-top: 36px;
    font-size: 32px;
  }

  #formaEspecifica {
    margin-top: 36px;
    display: flex;
    flex-direction: column;
    align-items: center;
    justify-content: center;
  }
</style><body><divclass="contenedor"><h1>Selecciona la forma que deseas para obtener el volumen</h1><selectstyle="margin-top: 24px;"id='forma'onchange="forma()"><optionvalue="null"></option><optionvalue="cilindro">Cilindro</option><optionvalue="cubo">Cubo</option><optionvalue="esfera">Esfera</option></select><divid='formaEspecifica'></div></div><script>
    function forma() {
      const forma = document.getElementById('forma').value
      switch(forma){
        case 'cilindro':
          const cilindro = document.getElementById('formaEspecifica')
          cilindro.innerHTML = `
          <h1>Volumen de un Cilindro</h1><divclass="datos"><div><sectionclass="section">
                Altura:
              </section><sectionclass="section">
                Radio:
              </section></div><divclass="inputs"><inputid="altura"placeholder="metros"/><inputid="radio"placeholder="metros"/></div></div><buttonid='btn'onclick="volumenCilindro()"class="btn">Calcular...</button><divclass='resultado'>
            El Volumen es: <spanid="resultado"></span></div>
          `
          break;
        case 'cubo':
          const cubo = document.getElementById('formaEspecifica')
          cubo.innerHTML = `
          <h1>Volumen de un Cubo</h1><divclass="datos"><div><sectionclass="section">
                Lado:
              </section></div><divclass="inputs"><inputid="lado"placeholder="metros"/></div></div><buttonid='btn'onclick="volumenCubo()"class="btn">Calcular...</button><divclass='resultado'>
            El Volumen es: <spanid="resultado"></span></div>
          `
          break;
        case 'esfera':
          const esfera = document.getElementById('formaEspecifica')
          esfera.innerHTML = `
          <h1>Volumen de una Esfera</h1><divclass="datos"><div><sectionclass="section">
                Radio:
              </section></div><divclass="inputs"><inputid="radio"placeholder="metros"/></div></div><buttonid='btn'onclick="volumenEsfera()"class="btn">Calcular...</button><divclass='resultado'>
            El Volumen es: <spanid="resultado"></span></div>
          `
          break;
      }
    }

    function volumenCilindro(){
      const h = parseFloat(document.getElementById('altura').value)
      const r = parseFloat(document.getElementById('radio').value)
      let resultado = Math.PI * (r**2) * h
      document.getElementById('resultado').innerHTML = resultado.toFixed(1) + ' metros cúbicos'
    }

    function volumenCubo(){
      const l = parseFloat(document.getElementById('lado').value)
      let resultado = l * l * l
      document.getElementById('resultado').innerHTML = resultado.toFixed(1) + ' metros cúbicos'
    }

    function volumenEsfera(){
      const r = parseFloat(document.getElementById('radio').value)
      let resultado = (4/3)*Math.PI*(r**3)
      document.getElementById('resultado').innerHTML = resultado.toFixed(1) + ' metros cúbicos'
    }
  </script></body></html>
1
5819Puntos

Python

from math import pi

import os

defcilindro():
    print('''Cilindro
    ''')
    radio = float(input('Ingrese el radio del cilindro en centimetros: '))
    altura = float(input('Ingrese la altura del cilindro en centimetros: '))
    volumen = pi * radio**2 * altura
    volumen = volumen.__round__(1)
    print()
    return print(f'El volumen del cilindro es de {volumen} cm^3')

defcubo():
    print('''Cubo
    ''')
    lado1 = float(input('Ingrese la medida del primer lado en centimetros: '))
    lado2 = float(input('Ingrese la medida del segundo lado en centimetros: '))
    lado3 = float(input('Ingrese la medida del tercer lado en centimetros: '))
    volumen = lado1 * lado2 * lado3
    volumen = volumen.__round__(1)
    print()
    return print(f'El volumen del cubo es de {volumen} cm^3')

defesfera():
    print('''Esfera
    ''')
    radio = float(input('Ingrese el radio de la esfera: '))
    volumen = 4/3 * pi * radio**3
    volumen = volumen.__round__(1)
    print()
    return print(f'El volumen de la esfera es de {volumen} cm^3')

defmenu():
    print()
    print('''MENU
    
    1. Cilindro
    2. Cubo
    3. Esfera
    4. Salir''')

defmain():whileTrue:
        menu()
        opcion = int(input('Elige una opcion: '))

        if opcion == 1:
            os.system('cls')
            cilindro()
        elif opcion == 2:
            os.system('cls')
            cubo()
        elif opcion == 3:
            os.system('cls')
            esfera()
        elif opcion == 4:
            exit()
        else:
            print('Opcion incorrecta.')


if __name__ == '__main__':
    print()
    print('CALCULADORA DE VOLUMENES')
    main()
1
18961Puntos
constPI = Math.PI;

const cylinder = p => {
    let askHeight = parseFloat(prompt('Enter the height'));
    let askRadio = parseFloat(prompt('Enter the radio'));

    letresult = (askHeight * p * (askRadio**2)).toFixed(1);
    return (`Height: ${askHeight} | Radio: ${askRadio} | The volume is: ${result} m³`);
};

const cube = () => {
    let askSide1 = parseFloat(prompt(`Enter the one side`));
    let askSide2 = parseFloat(prompt(`Enter the second side`));
    let askSide3 = parseFloat(prompt(`Enter the third side`));
    
    letresult = (askSide1 * askSide2 * askSide3).toFixed(1)
    return (`Side1: ${askSide1} | Side2: ${askSide2} | Side3: ${askSide3} | The volume is: ${result} m³`);
}

const sphere = p => {
    let askRadio = parseFloat(prompt('Enter the radio'));

    letresult = ((4/3) * p * (askRadio**3)).toFixed(1);
    return (`Radio: ${askRadio} | The volume is: ${result} m³`);
}

const printVolume = () => {
    let askFigure = prompt('Whatof the figure do you want to calculate the volume of? | Cylinder, cube or sphere').toLowerCase();
    if (askFigure === 'cylinder') {
        console.log(cylinder(PI));
    }
    elseif (askFigure === 'cube') {
        console.log(cube());
    }
    elseif (askFigure === 'sphere') {
        console.log(sphere(PI))
    }
    else {
        console.log('Please enter a valid figure')
    }
}
printVolume();


1
8870Puntos

En Java

clase Main

import java.util.Scanner;

public class Main {
    public static boolean menu(){
        System.out.println("Porfavor elige una opción:\n1.-Cilindro\n2.-Cubo\n3.-Esfera");
        Scanner entrada = new Scanner(System.in);int opcion = entrada.nextInt();System.out.println(opcion);switch (opcion) {
            case1:
                System.out.println("Dame el radio de tu cilindro en centimetros");
                Scanner s = new Scanner(System.in);
                float radioCilindro = s.nextFloat();System.out.println("Dame la altura de tu cilindro en centimetros");
                Scanner s2 = new Scanner(System.in);
                float alturaCilindro = s2.nextFloat();
                Cilindro cilindrito = new Cilindro(radioCilindro, alturaCilindro);
                cilindrito.CalcularArea();break;case2:
                System.out.println("Dame la altura de tu cubo en centimetros");
                Scanner s3 = new Scanner(System.in);
                float alturaCubo = s3.nextFloat();
                Cubo cubito = new Cubo(alturaCubo);
                cubito.calcularVolumen();break;case3:
                System.out.println("Dame el radio de tu esfera en centimetros");
                Scanner s4 = new Scanner(System.in);
                float radioEsfera = s4.nextFloat();
                Esfera esferita = new Esfera(radioEsfera);
                esferita.calcularVolumen();default:
                break;
        }
        System.out.println("Deseas calcular otro volumen (S/N)");
        Scanner scan= new Scanner(System.in);
        String respuesta=scan.nextLine();if(respuesta.equals("S") || respuesta.equals("s")){
            return true;
        }elseif(respuesta.equals("N") || respuesta.equals("n")){
            System.out.println("Hasta pronto");return false;
        }else{
            System.out.println("Opcion no valida");return false;
        }


    }
    public static void main(String[] args) {
        System.out.println("Bienvenido seas al programa para calcular volumenes");
        boolean nuevoCalculo;do {
            nuevoCalculo=menu();
        }while (nuevoCalculo);
    }
}

Clase Esfera

publicclassEsfera {
    privatefloat radio;
    privatefloat pi= 3.1416f;

    publicvoidsetRadio(float radio){
        this.radio=radio;
    }
    publicfloatgetRadio(){
        return radio;
    }
    publicEsfera(float radio){
        this.radio=radio;
    }

    publicvoidcalcularVolumen(){
        float volumen=(4f/3f)*pi*(radio*radio*radio);
        System.out.println("El volumen de tu esfera es de "+volumen+" centimetros cúbicos");
    }
}

Clase cubo

publicclassCubo {
    privatefloat altura;

    publicvoidsetAltura(float altura){
        this.altura=altura;
    }
    publicfloatgetAltura(){
        return  altura;
    }
    publicCubo(float altura){
        this.altura=altura;
    }

    publicvoidcalcularVolumen(){
        float volumen= altura*altura*altura;
        System.out.println("El volumen de tu cubo es de "+volumen+" centrimetros cúbicos");
    }
}

Clase Cilindro

publicclassCilindro {
    privatefloat radio;
    privatefloat altura;
    privatefloat pi= 3.1416f;

    publicvoidsetRadio(float radio){
        this.radio=radio;
    }
    publicfloatgetRadio(){
        return radio;
    }
    publicvoidsetAltura(float altura){
        this.altura=altura;
    }
    publicfloatgetAltura(){
        return  altura;
    }
    publicCilindro(float radio, float altura){
        this.altura=altura;
        this.radio=radio;
    }
    publicvoidCalcularArea(){
        float volumen=pi*(radio*radio)*altura;
        System.out.println("El volumen de tu cilindro es de "+ volumen+" centimetros cúbicos");
    }
}

1

Javascript

var figura = prompt('Cubo, Cilindro o Esfera?')

    switch(figura) {
        case ('cubo' || 'Cubo'):
            largo = prompt(`CUBO
            Ingresa el largo de la arista:`)
            alert((largo**3).toFixed(2) + ' m3')
            break;
        case ('cilindro' || 'Cilindro'):
            radio = prompt(`CILINDRO
            Ingresa el radio de la base:`)
            alto = prompt(`CILINDRO
            Ingresa la altura del cilindro:`)
            alert((radio**2*Math.PI*alto).toFixed(2)+ ' m3')
        case ('esfera' || 'Cilindro'):
            radio = prompt(`CILINDRO
            Ingresa el radio de la esfera:`)
            alert(((4*Math.PI*radio**3)/3).toFixed(2)+ ' m3')
        default:
            alert('Figura no valida')
    }      
0
9579Puntos

calculadora de volumenes - Python

from math import pi

defcilindro():
    r = float(input("Radio del cilindro: "))
    h = float(input("Altura del cilindro"))
    vol = pi * (r**2) * h
    print(round(vol, 2))

defesfera():
    radio = float(input("Ingresa el radio de la esfera: "))
    volumen = (4 * pi * radio**3)/3
    print(volumen)

defcubo():
    lado = float(input("Engresa el tamaños de un lado del cubo: "))
    volumen = lado **3
    print(volumen)

if __name__ == "__main__":
    print("Elije la figura que quieres calcular volumen, (1, 2, ó 3)")
    opcion = input("""
1 - cilindro
2 - esfera
3 - cubo
 """)
    whileTrue:
        if opcion == "1":
            cilindro()
            breakelif opcion =="2":
            esfera()
            breakelif opcion == "3":
            cubo()
            breakelse:
            print("Opcion incorrecta")
0
12398Puntos

Este challeng está en el challenge número 8:

import math

PI = math.pi

defsuperficieLateral(radio, altura):
  supLateral = (2*PI*radio) * altura
  supLateral = round(supLateral,1)
  print('La superficie lateral del cilindo: {}'.format(supLateral))

defvolumenCilinro(radio, altura):
  vol = PI * math.pow(radio,3)*altura
  vol = round(vol,1)
  print('El volumen es: {}'.format(vol))

if __name__ == '__main__':
  print('Programa para el volumen de un cilindro:')
  radio = int(input('Ingresa el radio de la base: '))
  altura = int(input('Ingresa la altura: '))

  volumenCilinro(radio, altura)
  superficieLateral(radio, altura)
0
12398Puntos

Va de nuevo, incluyendo el volumen del cubo, la esfera y del cilindro:

#Calculadora de volúmenes Cilindro, Cubo, Esferaimport math

PI = math.pi

defvolumenCilinro(radio, altura):
  vol = PI * math.pow(radio,3)*altura
  vol = round(vol,1)
  print('Volumen cilindro: {}'.format(vol))

defvolumenCubo(lado):
  vol = math.pow(lado,3)
  vol = round(vol,1)
  print('Volumen Cubo: {}'.format(vol))

defvolumenEsfera(radio):
  vol = (4/3) * PI * (math.pow(radio,3))
  vol = round(vol,1)
  print('Volumen esfera: {}'.format(vol))


defrun():whileTrue:
    opcion = int(input('''
            ¿Qué deseas calcular?
            [1] Volumen de un cilindro
            [2] Volumen de un Cubo
            [3] Volumen de una Esfera
            [4] Salir
            '''
            ))
    if opcion == 1:
      radio = int(input('Ingresa el radio de la base: '))
      altura = int(input('Ingresa la altura: '))
      volumenCilinro(radio, altura)

    elif opcion == 2:
      lado = int(input('Ingresa la medida del lado: '))
      volumenCubo(lado)

    elif opcion == 3:
      radio = int(input('Ingresa el radio de la esfera: '))
      volumenCubo(radio)

    elif opcion == 4:
      breakelse:
      print('Opción no válida.')


if __name__ == '__main__':
  run()