Selección múltiple
Mini calculadora
En algunas ocasiones durante la ejecución de un programa será necesario escoger entre mas de dos opciones, es decir que la condición no será un valor booleano (Falso o Verdadero) sino que podrá tener diferentes valores.
Para mostrar como solucionan esto los diferentes lenguajes realizaremos el siguiente ejercicio
Ejercicio:
Mini calculadora
Se le pide al usuario que ingrese dos números enteros y un operador (+, -, * o /) y el programa realizará la operación correspondiente.
En Java
Declararemos 3 variables tipo float para almacenar los datos ingresados y el resultado:
float num1, num2, resultado = 0;
Declararemos una variable tipo char para almacenar el operador
char operacion;
Creamos el objeto “dato” de la clase “Scanner”
Scanner dato = new Scanner(System.in);
Solicitamos los números
System.out.println(“Ingresa número entero”);
Solicitamos el operador
System.out.println(“Ingresa operador”);
Capturamos datos desde el teclado y almacenamos en las variables correspondientes
num1 = dato.nextFloat();
num2 = dato.nextFloat();
operacion = dato.next().charAt(0);
En este momento ya tenemos el operador con el cual seleccionaremos una de cuatro operaciones a realizar (+, -, * o /). Para poder escojer entre estás cuatro opciones Java tiene una estructura llamada “switch” que se escribe de la siguiente forma:
switch(valor){
case ‘valor_1’: Instruciones para valor_1…
break;
case ‘valor_2’: Instruciones para valor_2…
break;
case ‘valor_3’: Instruciones para valor_3…
break;
. .
. .
. .
case ‘valor_n’: Instruciones para valor_n…
break;
default : Instruciones si no corresponde con ninguno de los anteriores….
}
Esta estructura evalúa si el valor de una variable que coloquemos dentro de los parantecis se corresponde con alguno de los “case” (solo podrá corresponder a uno de ellos) y ejecutará las instrucciones respectivas, luego de ello encontrará un “break” que hará que el programa se salga de los corchetes y terminará la ejecución del “switch”. Si el “valor” no corresponde a ninguno de los “case” ejecutará las instrucciones programadas en “default”.
En nuestro caso la variable a evaluar será “operacion” que es un dato tipo char y los posibles valores que puede tomar (“case”) serán los caracteres de las operciones +, -, * y / realizando la operación respectiva y almacenando el resultado en la variable “resultado”; como son caracteres deberán estar entre comilla senclla. Si la “operación” no contiene ninguno de estos caracteres el programa mostrará el mensaje “Operador no valido”
switch(operacion){
case ‘+’: resultado = num1 + num2;
break;
case ‘-‘: resultado = num1 – num2;
break;
case ‘*’: resultado = num1 * num2;
break;
case ‘/’: resultado = num1 / num2;
break;
default : System.out.println(“Operador no valido”);
}
Después de finalizar el “switch” mostrará un mensaje con el resultado
System.out.println(num1+” “+operacion+” “+num2+” = “+resultado);
El código quedará:
package minicalculadora;
import java.util.Scanner;
public class Minicalculadora {
public static void main(String[] args) {
float num1, num2, resultado = 0;
char operacion;
Scanner dato = new Scanner(System.in);
System.out.println(“Ingresa número entero”);
num1 = dato.nextFloat();
System.out.println(“Ingresa operador”);
operacion = dato.next().charAt(0);
System.out.println(“Ingresa número entero”);
num2 = dato.nextFloat();
switch(operacion){
case ‘+’: resultado = num1 + num2;
break;
case ‘-‘: resultado = num1 – num2;
break;
case ‘*’: resultado = num1 * num2;
break;
case ‘/’: resultado = num1 / num2;
break;
default : System.out.println(“Operador no valido”);
}
System.out.println(num1+” “+operacion+” “+num2+” = “+resultado);
}
}
En Python
Mostramos mensaje para ingresar datos, capturamos el dato del teclado y lo almacenamos en una variable
num1=int(input(“ingresa un número\t”))
Hacemos lo mismo para el ingreso del operador
ope=input(“ingresa un operador\t”)
En este momento ya tenemos el operador con el cual seleccionaremos una de cuatro operaciones a realizar (+, -, * o /). Para poder escojer entre estás cuatro opciones Python tiene una estructura llamada “elif” que se escribe de la siguiente forma:
if condición_1 :
Instruciones a realizar
si se cumple la condición_1
elif condición_2 :
Instruciones a realizar
si se cumple la condición_2
elif condición_3 :
Instruciones a realizar
si se cumple la condición_3
.
.
.
.
elif condición_n :
Instruciones a realizar
si se cumple la condición_n
else:
Instruciones a realizar
si no se cumple ninguna de las condiciones anteriores
Es posible que de todas las condiciones anteriores hallan varias verdaderas, pero solo se ejecutará la primera. Else solo se ejecutará si ninguna es verdadera.
En nuestro caso tendremos cuatro condiciones a evaluar, es decir que la variable “ope” corresponda a uno de los caracteres ‘+’, ‘-‘, ‘*’, o ‘/’ y realizará la operación correspondiente mostrando el resultado.
Si “ope” no contiene ninguno de estos caracteres el programa ejecutará “else” mostrando el mensaje “Operador no valido“
if ope == ‘+’ :
print(num1,” “,ope,” “,num2,” = “,num1+num2)
elif ope == ‘-‘ :
print(num1,” “,ope,” “,num2,” = “,num1-num2)
elif ope == ‘*’ :
print(num1,” “,ope,” “,num2,” = “,num1*num2)
elif ope == ‘/’ :
print(num1,” “,ope,” “,num2,” = “,num1/num2)
else:
print(“operador no valido”)
El código quedará:
num1=int(input(“ingresa un número\t”))
ope=input(“ingresa un operador\t”)
num2=int(input(“ingresa otro número\t”))
if ope == ‘+’ :
print(num1,” “,ope,” “,num2,” = “,num1+num2)
elif ope == ‘-‘ :
print(num1,” “,ope,” “,num2,” = “,num1-num2)
elif ope == ‘*’ :
print(num1,” “,ope,” “,num2,” = “,num1*num2)
elif ope == ‘/’ :
print(num1,” “,ope,” “,num2,” = “,num1/num2)
else:
print(“operador no valido”)
Recordemos que para ejecutar este código debemos guardarlo con extensión .py y luego ejecutarlo desde consola con
python minicalculadora.py
En C++
Declararemos 3 variables tipo float para almacenar los datos ingresados y el resultado:
float num1, num2, resultado;
Declararemos una variable tipo char para almacenar el operador
char ope;
Solicitamos los números
cout<<“Ingresa un numero\t”;
Solicitamos el operador
cout<<“Ingresa el operador\t”;
Capturamos datos desde el teclado y almacenamos en las variables correspondientes
cin>>num1;
cin>>ope;
cin>>num2;
En este momento ya tenemos el operador con el cual seleccionaremos una de cuatro operaciones a realizar (+, -, * o /). Para poder escojer entre estás cuatro opciones C++ tiene una estructura llamada “switch” que se escribe de la siguiente forma:
switch(valor){
case ‘valor_1’: Instruciones para valor_1…
break;
case ‘valor_2’: Instruciones para valor_2…
break;
case ‘valor_3’: Instruciones para valor_3…
break;
. .
. .
. .
case ‘valor_n’: Instruciones para valor_n…
break;
default : Instruciones si no corresponde con ninguno de los anteriores….
}
Esta estructura evalúa si el valor de una variable que coloquemos dentro de los parantecis se corresponde con alguno de los “case” (solo podrá corresponder a uno de ellos) y ejecutará las instrucciones respectivas, luego de ello encontrará un “break” que hará que el programa se salga de los corchetes y terminará la ejecución del “switch”. Si el “valor” no corresponde a ninguno de los “case” ejecutará las instrucciones programadas en “default“.
En nuestro caso la variable a evaluar será “ope” que es un dato tipo char y los posibles valores que puede tomar (“case”) serán los caracteres de las operciones +, -, * y / realizando la operación respectiva y almacenando el resultado en la variable “resultado“; como son caracteres deberán estar entre comilla sencilla. Si la variable “ope” no contiene ninguno de estos caracteres el programa mostrará el mensaje “Operador no valido“
switch(ope){
case ‘+’: resultado = num1 + num2;
break;
case ‘-‘: resultado = num1 – num2;
break;
case ‘*’: resultado = num1 * num2;
break;
case ‘/’: resultado = num1 / num2;
break;
default : cout<<“Operador no valido\t”;
}
Después de finalizar el “switch” mostrará un mensaje con el resultado
cout<<num1<<” “<<ope<<” “<<num2<<” = “<<resultado;
El Código será:
#include <iostream>
using namespace std;
int main(){
float num1, num2, resultado;
char ope;
cout<<“Ingresa un numero\t”;
cin>>num1;
cout<<“Ingresa el operador\t”;
cin>>ope;
cout<<“Ingresa un numero\t”;
cin>>num2;
switch (ope){
case ‘+’: resultado = num1 + num2;
break;
case ‘-‘: resultado = num1 – num2;
break;
case ‘*’: resultado = num1 * num2;
break;
case ‘/’: resultado = num1 / num2;
break;
default : cout<<“Operador no valido\t”;
}
cout<<num1<<” “<<ope<<” “<<num2<<” = “<<resultado;
}
En Ruby
Mostramos mensaje para ingresar datos,
puts “Ingresa un número”
capturamos el dato del teclado y lo almacenamos en una variable
num1 = gets.to_i
Hacemos lo mismo para el ingreso del operador
puts “Ingresa un operador”
capturamos con chomp para que tome el caracter sin el salto de línea
ope = gets.chomp
En este momento ya tenemos el operador con el cual seleccionaremos una de cuatro operaciones a realizar (+, -, * o /). Para poder escojer entre estás cuatro opciones Ruby tiene una estructura llamada “case” que se escribe de la siguiente forma:
case variable
when condición_1
Instrucciones si se
cumple esta condición
when condición_2
Instrucciones si se
cumple esta condición
when condición_3
Instrucciones si se
cumple esta condición
.
.
.
when condición_n
Instrucciones si se
cumple esta condición
else
Instrucciones si no se
cumple ninguna condición
end
Solo se ejecutará una condición y else solo se ejecutará si ninguna es verdadera.
En nuestro caso tendremos cuatro condiciones a evaluar, es decir que la variable “ope” corresponda a uno de los caracteres ‘+’, ‘-‘, ‘*’, o ‘/’ y realizará la operación correspondiente mostrando el resultado.
Si “ope” no contiene ninguno de estos caracteres el programa ejecutará “else” mostrando el mensaje “Operador no valido“
case ope
when “+”
puts “#{num1} #{ope} #{num2} = #{num1 + num2}”
when “-“
puts “#{num1} #{ope} #{num2} = #{num1 – num2}”
when “*”
puts “#{num1} #{ope} #{num2} = #{num1 * num2}”
when “/”
puts “#{num1} #{ope} #{num2} = #{num1.to_f / num2.to_f}”
else
puts “operador no valido”
end
Debemos tener en cuenta que para la división convertiremos los números a float (usando .to_f) para que el resultado me muestre los puntos decimales.
El Código será:
puts “Ingresa un número”
num1 = gets.to_i
puts “Ingresa un operador”
ope = gets.chomp
puts “Ingresa otro número”
num2 = gets.to_i
case ope
when “+”
puts “#{num1} #{ope} #{num2} = #{num1 + num2}”
when “-“
puts “#{num1} #{ope} #{num2} = #{num1 – num2}”
when “*”
puts “#{num1} #{ope} #{num2} = #{num1 * num2}”
when “/”
puts “#{num1} #{ope} #{num2} = #{num1.to_f / num2.to_f}”
else
puts “operador no valido”
end
En C#
Declararemos 2 variables tipo float para almacenar los datos ingresados:
float num1, num2;
Declararemos una variable tipo char para almacenar el operador
char ope;
Solicitamos los números
Console.WriteLine(“Ingrese un número”);
Solicitamos el operador
Console.WriteLine(“Ingrese un operador”);
Capturamos datos desde el teclado y almacenamos en las variables correspondientes
num1 = float.Parse(Console.ReadLine());
ope = Console.ReadLine().ToCharArray()[0];
Console.WriteLine(“Ingrese otro número”);
En este momento ya tenemos el operador con el cual seleccionaremos una de cuatro operaciones a realizar (+, -, * o /). Para poder escojer entre estás cuatro opciones C# tiene una estructura llamada “switch” que se escribe de la siguiente forma:
switch(variables){
case ‘valor_1’: Instruciones para valor_1…
break;
case ‘valor_2’: Instruciones para valor_2…
break;
case ‘valor_3’: Instruciones para valor_3…
break;
. .
. .
. .
case ‘valor_n’: Instruciones para valor_n…
break;
default : Instruciones si no corresponde
con ninguno de los anteriores….
}
Esta estructura evalúa si el valor de una variable que coloquemos dentro de los paréntesis corresponde alguno de los “case” (solo podrá corresponder a uno de ellos) y ejecutará las instrucciones respectivas, luego de ello encontrará un “break” que hará que el programa se salga de los corchetes y terminará la ejecución del “switch”. Si el “valor” no corresponde a ninguno de los “case” ejecutará las instrucciones programadas en “default“.
En nuestro caso la variable a evaluar será “ope” que es un dato tipo char y los posibles valores que puede tomar (“case”) serán los caracteres de las operciones +, -, * y / realizando la operación respectiva y almacenando el resultado en la variable “resultado”; como son caracteres deberán estar entre comilla senclla. Si la variable “ope” no contiene ninguno de estos caracteres el programa mostrará el mensaje “Operador no valido“
switch (ope)
{
case ‘+’:
Console.WriteLine($”{num1} {ope} {num2} = {num1 + num2} “);
break;
case ‘-‘:
Console.WriteLine($”{num1} {ope} {num2} = {num1 – num2} “);
break;
case ‘*’:
Console.WriteLine($”{num1} {ope} {num2} = {num1 * num2} “);
break;
case ‘/’:
Console.WriteLine($”{num1} {ope} {num2} = {num1 / num2} “);
break;
default: Console.WriteLine(“Operadpr no valido”);
break;
}
El Código será:
namespace minicalculadoraCs
{
class Program
{
static void Main(string[] args)
{
float num1, num2;
char ope;
Console.WriteLine(“Ingrese un número”);
num1 = float.Parse(Console.ReadLine());
Console.WriteLine(“Ingrese un operador”);
ope = Console.ReadLine().ToCharArray()[0];
Console.WriteLine(“Ingrese otro número”);
num2 = float.Parse(Console.ReadLine());
switch (ope)
{
case ‘+’:
Console.WriteLine($”{num1} {ope} {num2} = {num1 + num2} “);
break;
case ‘-‘:
Console.WriteLine($”{num1} {ope} {num2} = {num1 – num2} “);
break;
case ‘*’:
Console.WriteLine($”{num1} {ope} {num2} = {num1 * num2} “);
break;
case ‘/’:
Console.WriteLine($”{num1} {ope} {num2} = {num1 / num2} “);
break;
default: Console.WriteLine(“Operadpr no valido”);
break;
}
}
}
}