Crie um algoritmo e um programa que leia as 3 notas de um aluno e escreva “APROVADO” caso a média aritmética for maior ou igual a 6, caso contrário escreva “REPROVADO”

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.

O que podemos aprender neste exercício?

Este exercício proporciona uma oportunidade para aprender e praticar os seguintes conceitos:

1. Entrada e Saída de Dados: Você aprendeu várias maneiras de interagir com o usuário para obter informações através de entrada de dados e exibir resultados por meio de saída de dados.
2. Cálculos Simples: Você implementou um cálculo básico para encontrar a média aritmética das notas fornecidas pelo usuário.
3. Estruturas de Controle: Utilizou estruturas de decisão (como if e else) para determinar se o aluno estava aprovado ou reprovado com base na média calculada.
4. Lidando com Erros e Exceções: Em algumas linguagens, como Python e Go, foi necessário lidar com a possibilidade de entrada de dados inválida ou inesperada, garantindo que o programa continuasse funcionando corretamente.
5. Prática de Sintaxe: Este exercício permitiu praticar a sintaxe básica das linguagens de programação usadas (C++, C, Pascal, Python, C#, Java, Rust e Go).

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!

Exemplo em C++

/******************************************************************************

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:

1. Entrada de Dados: O programa solicita ao usuário que insira as três notas do aluno, armazenando cada uma delas em variáveis separadas (nota1, nota2 e nota3).
2. Cálculo da Média: Em seguida, o programa calcula a média aritmética das três notas, somando-as e dividindo o resultado por 3. O valor da média é armazenado na variável media.
3. Decisão de Aprovação ou Reprovação: O programa verifica se a média calculada é maior ou igual a 6. Se for, o programa imprime “APROVADO”. Caso contrário, imprime “REPROVADO”.
4. Saída de Dados: O resultado da aprovação ou reprovação é exibido na tela.

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.

Exemplo em C

/******************************************************************************

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", &nota1);

    printf("Digite a segunda nota: ");
    scanf("%f", &nota2);

    printf("Digite a terceira nota: ");
    scanf("%f", &nota3);

    // 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.

Exemplo em Pascal / Delphi / Lazarus

(*

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.

Exemplo em Python

'''

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.

Exemplo em C# / C Sharp

/******************************************************************************

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.

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);
        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.

Exemplo em Rust

/******************************************************************************

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.

Exemplo em Go

/******************************************************************************

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.

Conclusão

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