Exercício: operação definida por um código (a, b, c)
Fala galera da programação, tudo beleza? Vamos a um novo exercício para aprimorarmos nossas habilidades. Aqui existem dados importantes para podermos realizar a tarefa.
Dados do exercício
Tabela de códigos:
- código = 1: multiplicar os três valores
- código = 2: somar os três valores
- código = 3: subtrair os três valores
- código = 4: somar o cubo dos 3 valores
Exemplos de saída
Exemplo 1
Valores informados pelo usuário: Código: 3 a = 15 b=30 c=90
Mensagens mostradas na tela: Resultado da subtração: 75
Exemplo 2
Valores informados pelo usuário: Código: 4 a = 2 b=3 c=5
Mensagens mostradas na tela: Soma dos cubos: 160
O que podemos aprender neste exercício?
Neste exercício, podemos aprender várias coisas:
- Lógica de Programação: A implementação de um programa que lida com entrada do usuário e realiza operações com base em diferentes condições requer uma compreensão sólida da lógica de programação.
- Estruturas de Controle: Utilizamos estruturas de controle como
switch-case(oumatchem Rust) para determinar qual operação executar com base no código fornecido pelo usuário. - Entrada e Saída: A interação com o usuário é feita por meio de entrada e saída de dados, utilizando métodos apropriados dependendo da linguagem de programação escolhida.
- Manipulação de Dados: A capacidade de manipular dados inseridos pelo usuário é fundamental. No exercício, convertemos esses dados para os tipos apropriados e realizamos operações com eles.
- Validação de Entrada: É importante validar a entrada do usuário para garantir que o programa funcione corretamente e que não ocorram erros inesperados. No caso deste exercício, validamos se o código inserido está dentro do intervalo esperado.
- Conversão de Tipos: Em linguagens como Python, C# e Java, é necessário converter os dados inseridos pelo usuário para os tipos apropriados antes de usá-los em operações matemáticas.
- Estrutura de Decisão: O uso de estruturas de decisão (
if-else,switch-case,match) é essencial para determinar o comportamento do programa com base nas entradas do usuário. - Manuseio de Erros: Em algumas linguagens, é necessário lidar explicitamente com erros que podem ocorrer durante a entrada de dados ou a execução do programa.
Vamos aos códigos!
Exemplo em C++
/******************************************************************************
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*******************************************************************************/
#include <iostream>
#include <cmath>
using namespace std;
int main() {
int codigo;
double a, b, c;
cout << "Digite o codigo (1 a 4): ";
cin >> codigo;
cout << "Digite os tres valores (a, b e c): ";
cin >> a >> b >> c;
switch (codigo) {
case 1:
cout << "Resultado da multiplicacao: " << (a * b * c) << endl;
break;
case 2:
cout << "Resultado da soma: " << (a + b + c) << endl;
break;
case 3:
cout << "Resultado da subtracao: " << (a - b - c) << endl;
break;
case 4:
cout << "Resultado da soma dos cubos: " << (pow(a, 3) + pow(b, 3) + pow(c, 3)) << endl;
break;
default:
cout << "Codigo invalido! Por favor, digite um codigo entre 1 e 4." << endl;
return 1;
}
return 0;
}
Neste programa, o usuário insere um código e três valores, e o programa executa a operação correspondente de acordo com o código fornecido. O programa também inclui uma verificação para garantir que o código fornecido esteja na faixa válida de 1 a 4.
A estratégia utilizada foi:
- Solicitar ao usuário que inserisse um código e três valores (a, b e c).
- Utilizar um switch-case para determinar qual operação realizar com base no código fornecido pelo usuário.
- Dentro de cada caso do switch-case, executar a operação correspondente (multiplicação, soma, subtração ou soma dos cubos) e imprimir o resultado.
- Incluir um caso padrão para lidar com códigos inválidos, ou seja, códigos que não estão na faixa de 1 a 4.
- Retornar 1 se um código inválido for inserido para indicar que houve um erro.
- Retornar 0 ao final do programa para indicar que ele foi executado com sucesso.
Exemplo em C
/******************************************************************************
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*******************************************************************************/
#include <stdio.h>
#include <math.h>
int main() {
int codigo;
double a, b, c;
printf("Digite o codigo (1 a 4): ");
scanf("%d", &codigo);
printf("Digite os tres valores (a, b e c): ");
scanf("%lf %lf %lf", &a, &b, &c);
switch (codigo) {
case 1:
printf("Resultado da multiplicacao: %.2lf\n", a * b * c);
break;
case 2:
printf("Resultado da soma: %.2lf\n", a + b + c);
break;
case 3:
printf("Resultado da subtracao: %.2lf\n", a - b - c);
break;
case 4:
printf("Resultado da soma dos cubos: %.2lf\n", pow(a, 3) + pow(b, 3) + pow(c, 3));
break;
default:
printf("Codigo invalido! Por favor, digite um codigo entre 1 e 4.\n");
return 1;
}
return 0;
}
Neste código em C, a estrutura é semelhante à versão em C++. A diferença principal está na utilização de printf e scanf para entrada e saída de dados em vez de cout e cin, e a inclusão de #include <stdio.h> para a utilização dessas funções. Fora isso, a lógica e a estrutura do programa são praticamente idênticas à versão em C++.
Exemplo em Pascal / Delphi / Lazarus
{
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
}
program Calculadora;
uses
Math;
var
codigo: integer;
a, b, c: real;
begin
write('Digite o codigo (1 a 4): ');
readln(codigo);
write('Digite os tres valores (a, b e c): ');
readln(a, b, c);
case codigo of
1: writeln('Resultado da multiplicacao: ', a * b * c :0:2);
2: writeln('Resultado da soma: ', a + b + c :0:2);
3: writeln('Resultado da subtracao: ', a - b - c :0:2);
4: writeln('Resultado da soma dos cubos: ', power(a, 3) + power(b, 3) + power(c, 3) :0:2);
else
writeln('Codigo invalido! Por favor, digite um codigo entre 1 e 4.');
exit;
end;
end.
Neste programa em Pascal, a estrutura é bastante semelhante às versões em C e C++. A entrada e saída de dados são tratadas com readln e writeln. O case of é usado para determinar a operação com base no código fornecido pelo usuário, e power é usado para calcular o cubo dos valores. A instrução exit é usada para encerrar o programa imediatamente caso o código fornecido seja inválido.
Exemplo em Python
'''
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
'''
def main():
codigo = int(input("Digite o codigo (1 a 4): "))
a, b, c = map(float, input("Digite os tres valores (a, b e c): ").split())
if codigo == 1:
print("Resultado da multiplicacao:", a * b * c)
elif codigo == 2:
print("Resultado da soma:", a + b + c)
elif codigo == 3:
print("Resultado da subtracao:", a - b - c)
elif codigo == 4:
print("Resultado da soma dos cubos:", a ** 3 + b ** 3 + c ** 3)
else:
print("Codigo invalido! Por favor, digite um codigo entre 1 e 4.")
if __name__ == "__main__":
main()
Neste programa em Python, utilizamos a função input para receber os valores do usuário. A função map é usada para converter os valores para o tipo float. Em seguida, usamos estruturas condicionais (if, elif, else) para determinar a operação com base no código fornecido pelo usuário. Finalmente, chamamos a função main para iniciar o programa. Aqui quando for digitar os 3 valores, digite-os separando com espaços em branco. Exemplo: (5 22 33)
Criamos outro exemplo que é válido para Python a partir da versão 3.10
def main():
codigo = int(input("Digite o código (1 a 4): "))
a, b, c = map(float, input("Digite os três valores (a, b e c): ").split())
resultado = match codigo:
case 1:
a * b * c
case 2:
a + b + c
case 3:
a - b - c
case 4:
a ** 3 + b ** 3 + c ** 3
case _:
"Código inválido! Por favor, digite um código entre 1 e 4."
print(resultado)
if __name__ == "__main__":
main()
A partir da versão 3.10 do Python, foi introduzida a sintaxe match, que permite fazer seleções condicionais mais complexas e semelhantes ao switch-case encontrado em outras linguagens. Observe que o match é uma funcionalidade relativamente nova em Python e pode não estar disponível em versões mais antigas da linguagem. Neste exemplo, a expressão match é utilizada para determinar o resultado com base no código fornecido pelo usuário. Cada case corresponde a uma operação específica, e o resultado é atribuído à variável resultado. Se o código fornecido não corresponder a nenhum case, a mensagem de erro é atribuída à variável resultado. Finalmente, o resultado é impresso na tela.
Exemplo em C# / C Sharp
/******************************************************************************
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*******************************************************************************/
using System;
class Program
{
static void Main()
{
Console.Write("Digite o código (1 a 4): ");
int codigo = int.Parse(Console.ReadLine());
Console.Write("Digite os três valores (a, b e c): ");
string[] valores = Console.ReadLine().Split();
double a = double.Parse(valores[0]);
double b = double.Parse(valores[1]);
double c = double.Parse(valores[2]);
switch (codigo)
{
case 1:
Console.WriteLine("Resultado da multiplicação: " + (a * b * c));
break;
case 2:
Console.WriteLine("Resultado da soma: " + (a + b + c));
break;
case 3:
Console.WriteLine("Resultado da subtração: " + (a - b - c));
break;
case 4:
Console.WriteLine("Resultado da soma dos cubos: " + (Math.Pow(a, 3) + Math.Pow(b, 3) + Math.Pow(c, 3)));
break;
default:
Console.WriteLine("Código inválido! Por favor, digite um código entre 1 e 4.");
break;
}
}
}
Neste programa em C#, utilizamos a classe Console para interagir com o usuário, solicitando a entrada do código e dos três valores. Em seguida, usamos int.Parse e double.Parse para converter os valores de entrada para os tipos apropriados. A operação é determinada usando um switch com base no código fornecido pelo usuário, e o resultado é exibido na tela.
Exemplo em Java
/******************************************************************************
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*******************************************************************************/
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Digite o código (1 a 4): ");
int codigo = scanner.nextInt();
System.out.print("Digite os três valores (a, b e c): ");
double a = scanner.nextDouble();
double b = scanner.nextDouble();
double c = scanner.nextDouble();
switch (codigo) {
case 1:
System.out.println("Resultado da multiplicação: " + (a * b * c));
break;
case 2:
System.out.println("Resultado da soma: " + (a + b + c));
break;
case 3:
System.out.println("Resultado da subtração: " + (a - b - c));
break;
case 4:
System.out.println("Resultado da soma dos cubos: " + (Math.pow(a, 3) + Math.pow(b, 3) + Math.pow(c, 3)));
break;
default:
System.out.println("Código inválido! Por favor, digite um código entre 1 e 4.");
break;
}
scanner.close();
}
}
Neste programa em Java, utilizamos a classe Scanner para receber entrada do usuário. Em seguida, usamos um switch para determinar a operação com base no código fornecido pelo usuário. O resultado é exibido na tela com a função println().
Exemplo em Rust
/******************************************************************************
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*******************************************************************************/
use std::io;
fn main() {
println!("Digite o código (1 a 4): ");
let mut codigo = String::new();
io::stdin().read_line(&mut codigo).expect("Falha ao ler linha.");
let codigo: u32 = codigo.trim().parse().expect("Por favor, digite um número válido.");
println!("Digite os três valores (a, b e c): ");
let mut valores = String::new();
io::stdin().read_line(&mut valores).expect("Falha ao ler linha.");
let mut valores_iter = valores.split_whitespace();
let a: f64 = valores_iter.next().expect("Valor de a não fornecido.").parse().expect("Por favor, digite um número válido.");
let b: f64 = valores_iter.next().expect("Valor de b não fornecido.").parse().expect("Por favor, digite um número válido.");
let c: f64 = valores_iter.next().expect("Valor de c não fornecido.").parse().expect("Por favor, digite um número válido.");
match codigo {
1 => println!("Resultado da multiplicação: {}", a * b * c),
2 => println!("Resultado da soma: {}", a + b + c),
3 => println!("Resultado da subtração: {}", a - b - c),
4 => println!("Resultado da soma dos cubos: {}", a.powi(3) + b.powi(3) + c.powi(3)),
_ => println!("Código inválido! Por favor, digite um código entre 1 e 4."),
}
}
Neste programa em Rust, utilizamos a macro println! para exibir mensagens na tela. Utilizamos io::stdin().read_line() para ler a entrada do usuário e parse() para converter os valores para os tipos apropriados. O match é usado para determinar a operação com base no código fornecido pelo usuário.
Conclusão
Em resumo, este exercício pode ajudar a reforçar conceitos fundamentais de programação e a prática na implementação de soluções simples, porém práticas, para problemas do mundo real.
Beleza pessoal? Espero que tenham gostado.
Dúvidas ou sugestões de outras linguagens? Deixe o seu comentário!
Um abraço e até o próximo post. Valeu!
