Fala galera da programação, tudo beleza?
Hoje vamos descubra como este simples exercício de programação em várias linguagens pode fortalecer suas habilidades de codificação! 🚀 Aprenda a calcular médias de notas e determinar a aprovação ou reprovação de alunos em C++, C, Pascal, Python, C#, Java, Rust e Go.
Este exercício proporciona uma oportunidade para aprender e praticar os seguintes conceitos:
if e else) para determinar se o aluno estava aprovado ou reprovado com base na média calculada.Além disso, ao comparar a implementação do mesmo problema em várias linguagens, você pode notar diferenças e semelhanças na sintaxe, paradigmas de programação e ferramentas disponíveis em cada uma delas. Isso pode ajudá-lo a entender melhor as características únicas de cada linguagem e a tomar decisões mais informadas sobre qual usar em diferentes situações.
Vamos aos códigos!
/******************************************************************************
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*******************************************************************************/
#include <iostream>
using namespace std;
int main() {
float nota1, nota2, nota3;
float media;
// Solicita as notas ao usuário
cout << "Digite a primeira nota: ";
cin >> nota1;
cout << "Digite a segunda nota: ";
cin >> nota2;
cout << "Digite a terceira nota: ";
cin >> nota3;
// Calcula a média aritmética
media = (nota1 + nota2 + nota3) / 3;
// Verifica se o aluno está aprovado ou reprovado
if (media >= 6.0) {
cout << "APROVADO" << endl;
} else {
cout << "REPROVADO" << endl;
}
return 0;
}
Este programa solicita ao usuário que insira as três notas do aluno e, em seguida, calcula a média aritmética dessas notas. Com base na média calculada, ele imprime “APROVADO” se a média for maior ou igual a 6, caso contrário, imprime “REPROVADO”.
A estratégia utilizada neste programa é bastante direta:
nota1, nota2 e nota3).media.Essa estratégia segue de perto o enunciado do problema, que basicamente envolve a entrada de dados (notas), o cálculo da média e a decisão baseada nessa média.
/******************************************************************************
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*******************************************************************************/
#include <stdio.h>
int main() {
float nota1, nota2, nota3;
float media;
// Solicita as notas ao usuário
printf("Digite a primeira nota: ");
scanf("%f", ¬a1);
printf("Digite a segunda nota: ");
scanf("%f", ¬a2);
printf("Digite a terceira nota: ");
scanf("%f", ¬a3);
// Calcula a média aritmética
media = (nota1 + nota2 + nota3) / 3;
// Verifica se o aluno está aprovado ou reprovado
if (media >= 6.0) {
printf("APROVADO\n");
} else {
printf("REPROVADO\n");
}
return 0;
}
Neste programa em C, as funções printf() e scanf() são usadas para entrada e saída de dados, respectivamente. A lógica geral do programa permanece a mesma que na versão em C++, mas a sintaxe e algumas das funções utilizadas são diferentes para se adequarem à linguagem C.
(*
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*)
program VerificaAprovacao;
var
nota1, nota2, nota3: real;
media: real;
begin
// Solicita as notas ao usuário
writeln('Digite a primeira nota: ');
readln(nota1);
writeln('Digite a segunda nota: ');
readln(nota2);
writeln('Digite a terceira nota: ');
readln(nota3);
// Calcula a média aritmética
media := (nota1 + nota2 + nota3) / 3;
// Verifica se o aluno está aprovado ou reprovado
if media >= 6.0 then
writeln('APROVADO')
else
writeln('REPROVADO');
end.
Neste programa em Pascal, usamos as instruções writeln e readln para entrada e saída de dados, respectivamente. O cálculo da média e a lógica de decisão são semelhantes aos programas anteriores, mas adaptados à sintaxe do Pascal.
'''
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
'''
# Solicita as notas ao usuário
nota1 = float(input("Digite a primeira nota: "))
nota2 = float(input("Digite a segunda nota: "))
nota3 = float(input("Digite a terceira nota: "))
# Calcula a média aritmética
media = (nota1 + nota2 + nota3) / 3
# Verifica se o aluno está aprovado ou reprovado
if media >= 6.0:
print("APROVADO")
else:
print("REPROVADO")
Em Python, a entrada de dados é feita com a função input(), que retorna uma string, então usamos a função float() para converter a entrada em números de ponto flutuante. O cálculo da média e a lógica de decisão são bastante diretos e semelhantes aos outros exemplos.
/******************************************************************************
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*******************************************************************************/
using System;
class Program
{
static void Main(string[] args)
{
float nota1, nota2, nota3;
float media;
// Solicita as notas ao usuário
Console.Write("Digite a primeira nota: ");
nota1 = float.Parse(Console.ReadLine());
Console.Write("Digite a segunda nota: ");
nota2 = float.Parse(Console.ReadLine());
Console.Write("Digite a terceira nota: ");
nota3 = float.Parse(Console.ReadLine());
// Calcula a média aritmética
media = (nota1 + nota2 + nota3) / 3;
// Verifica se o aluno está aprovado ou reprovado
if (media >= 6.0)
{
Console.WriteLine("APROVADO");
}
else
{
Console.WriteLine("REPROVADO");
}
}
}
Em C#, utilizamos a classe Console para entrada e saída de dados. A entrada é feita com Console.ReadLine(), e a conversão para float é realizada com float.Parse(). O restante do programa é semelhante à lógica dos exemplos anteriores.
/******************************************************************************
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);
float nota1, nota2, nota3;
float media;
// Solicita as notas ao usuário
System.out.print("Digite a primeira nota: ");
nota1 = scanner.nextFloat();
System.out.print("Digite a segunda nota: ");
nota2 = scanner.nextFloat();
System.out.print("Digite a terceira nota: ");
nota3 = scanner.nextFloat();
// Calcula a média aritmética
media = (nota1 + nota2 + nota3) / 3;
// Verifica se o aluno está aprovado ou reprovado
if (media >= 6.0) {
System.out.println("APROVADO");
} else {
System.out.println("REPROVADO");
}
scanner.close();
}
}
Em Java, utilizamos a classe Scanner para entrada de dados. As notas são lidas com o método nextFloat() e armazenadas em variáveis de tipo float. O restante do programa é semelhante à lógica dos exemplos anteriores. É importante fechar o objeto Scanner no final para liberar recursos.
/******************************************************************************
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*******************************************************************************/
use std::io;
fn main() {
let mut input = String::new();
let mut notas = Vec::new();
// Solicita as notas ao usuário
println!("Digite a primeira nota:");
io::stdin().read_line(&mut input).expect("Falha ao ler a linha");
let nota1: f32 = input.trim().parse().expect("Por favor, insira um número válido");
notas.push(nota1);
input.clear();
println!("Digite a segunda nota:");
io::stdin().read_line(&mut input).expect("Falha ao ler a linha");
let nota2: f32 = input.trim().parse().expect("Por favor, insira um número válido");
notas.push(nota2);
input.clear();
println!("Digite a terceira nota:");
io::stdin().read_line(&mut input).expect("Falha ao ler a linha");
let nota3: f32 = input.trim().parse().expect("Por favor, insira um número válido");
notas.push(nota3);
// Calcula a média aritmética
let media: f32 = notas.iter().sum::<f32>() / 3.0;
// Verifica se o aluno está aprovado ou reprovado
if media >= 6.0 {
println!("APROVADO");
} else {
println!("REPROVADO");
}
}
Neste código em Rust, usamos a macro println! para imprimir mensagens no console e io::stdin().read_line() para ler as entradas do usuário. Os valores lidos são convertidos em f32 e armazenados em um vetor. Em seguida, calculamos a média aritmética usando o método iter().sum::<f32>() e verificamos se o aluno está aprovado ou reprovado.
/******************************************************************************
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*******************************************************************************/
package main
import (
"fmt"
"strconv"
)
func main() {
var nota1, nota2, nota3 float64
// Solicita as notas ao usuário
fmt.Println("Digite a primeira nota:")
nota1 = lerNota()
fmt.Println("Digite a segunda nota:")
nota2 = lerNota()
fmt.Println("Digite a terceira nota:")
nota3 = lerNota()
// Calcula a média aritmética
media := (nota1 + nota2 + nota3) / 3.0
// Verifica se o aluno está aprovado ou reprovado
if media >= 6.0 {
fmt.Println("APROVADO")
} else {
fmt.Println("REPROVADO")
}
}
// Função para ler notas do usuário
func lerNota() float64 {
var input string
fmt.Scanln(&input)
nota, err := strconv.ParseFloat(input, 64)
if err != nil {
fmt.Println("Erro ao ler a nota:", err)
return lerNota()
}
return nota
}
Neste programa em Go, usamos a função fmt.Println() para exibir mensagens no console e fmt.Scanln() para ler as entradas do usuário. Para garantir que a entrada seja um número válido, usamos strconv.ParseFloat(). O cálculo da média aritmética e a verificação da aprovação ou reprovação são feitos da mesma forma que nos exemplos anteriores.
O exercício de implementar um programa para calcular a média de notas de um aluno e determinar se ele está aprovado ou reprovado foi uma excelente oportunidade para explorar conceitos fundamentais de programação em diferentes linguagens. Ao escrever o código em várias linguagens, pudemos comparar e contrastar suas sintaxes, estruturas de controle e abordagens para lidar com entrada e saída de dados.
Por meio deste exercício, consolidamos nosso conhecimento sobre como solicitar entrada de dados do usuário, realizar cálculos simples e tomar decisões com base nos resultados. Além disso, aprendemos a lidar com erros e exceções, garantindo a robustez e a confiabilidade de nossos programas.
Ao analisar as diferentes implementações em linguagens como C++, C, Pascal, Python, C#, Java, Rust e Go, pudemos apreciar a diversidade de abordagens que cada linguagem oferece para resolver o mesmo problema.
No geral, este exercício proporcionou uma valiosa oportunidade de prática e aprendizado, ajudando-nos a aprimorar nossas habilidades de programação e a compreender melhor as nuances das diferentes linguagens de programação. Essa experiência será útil ao enfrentarmos desafios futuros de programação em uma variedade de contextos.
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!
#Algoritmos
#Programação
#Aprendizado
#LinguagensDeProgramação
#DesenvolvimentoDeSoftware
#GiovaniDaCruz
Está gostando do conteúdo?
Considere pagar um cafezinho para nossa equipe!
