Crie um algoritmo e um programa quesolicite o usuário informar a altura em metros e o sexo de uma pessoa. O programa deverá calcular o peso ideal da pessoa, utilizando as seguintes fórmulas:

Fala galera da programação, tudo beleza? Lá vamos nós a mais um interessante exercício.

Dados do Exercício

Formulas
Para Homens: ( 72.7 * altura ) – 58
Para Mulheres: ( 62.1 * altura) – 44.7

Mais dicas

A altura da pessoa é um valor real.
O sexo da pessoa deverá ser identificado através de um caracter.
O programa deverá aceitar os caracteres “m” ou “M” para identificar pessoas do sexo masculino e os caracteres “f” ou “F” para identificar pessoas do sexo feminino.
A variável que identifica o sexo deve ser declarada com o tipo char.

Exemplo 1

Valores informados pelo usuário: Altura: 1.6 e Sexo: F

Mensagens mostradas na tela: Peso ideal: 54,7kg

Exemplo 2

Valores informados pelo usuário: Altura: 1.8 e Sexo: M

Mensagens mostradas na tela: Peso ideal: 72,9 kg

O que podemos aprender neste exercício?

Neste exercício, podemos aprender várias coisas:

1. Manipulação de Entrada do Usuário: Aprendemos como solicitar e receber entrada do usuário em diferentes linguagens de programação, como C++, C, Pascal, Python, Java, Rust e Go. Cada linguagem tem suas próprias maneiras de fazer isso, mas a essência é a mesma: pedir informações ao usuário e armazená-las para uso posterior.
2. Estruturas de Controle: Aprendemos como usar estruturas de controle de fluxo, como condicionais (if-else ou switch-case), para tomar decisões com base nas entradas do usuário. Isso nos permite lidar com diferentes cenários e responder de acordo com as condições especificadas.
3. Cálculos Simples: Praticamos realizar cálculos simples com base nas entradas do usuário. Isso envolveu operações matemáticas básicas, como multiplicação, subtração e adição, para calcular o peso ideal com base na altura e sexo fornecidos.
4. Formatação de Saída: Aprendemos como formatar a saída para que os resultados sejam exibidos de maneira legível e informativa para o usuário. Isso inclui especificar o número de casas decimais ou formatar uma string de maneira adequada para exibição.
5. Gerenciamento de Erros e Exceções: Em alguns exemplos, lidamos com casos em que o usuário fornece entradas inválidas, como um sexo não reconhecido. Aprendemos a como lidar com essas situações, exibindo mensagens de erro apropriadas e encerrando o programa de forma adequada.
6. Adaptação a Diferentes Linguagens: Ao escrever o mesmo programa em várias linguagens, podemos comparar e contrastar as diferenças de sintaxe, estilo e paradigmas de programação entre essas linguagens. Isso nos permite entender como conceitos similares são expressos de maneiras diferentes em diferentes ambientes de programação.

Em resumo, este exercício nos permite praticar habilidades fundamentais de programação, como entrada/saída, controle de fluxo, cálculos matemáticos simples e formatação de saída, enquanto nos familiarizamos com várias linguagens de programação. Isso nos ajuda a expandir nosso conhecimento e habilidades como programadores.

Vamos aos códigos!

Exemplo em C++

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

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*******************************************************************************/
#include <iostream>

using namespace std;

int main() {
    // Declaração das variáveis
    double altura, peso_ideal;
    char sexo;

    // Solicita a entrada do usuário
    cout << "Altura (metros): ";
    cin >> altura;
    cout << "Sexo (M/F): ";
    cin >> sexo;

    // Verifica o sexo e calcula o peso ideal
    if (sexo == 'm' || sexo == 'M') {
        peso_ideal = (72.7 * altura) - 58;
    } else if (sexo == 'f' || sexo == 'F') {
        peso_ideal = (62.1 * altura) - 44.7;
    } else {
        cout << "Sexo inválido. Por favor, insira 'M' para masculino ou 'F' para feminino." << endl;
        return 1; // Encerra o programa com código de erro
    }

    // Exibe o peso ideal
    cout << "Peso ideal: " << peso_ideal << " kg" << endl;

    return 0;
}

Este programa solicita ao usuário a altura em metros e o sexo da pessoa. Em seguida, ele calcula e exibe o peso ideal conforme as fórmulas fornecidas, considerando o sexo informado. O programa verifica se o sexo inserido é válido e, caso contrário, exibe uma mensagem de erro e encerra com um código de erro.

Exemplo em C

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

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*******************************************************************************/
#include <stdio.h>

int main() {
    // Declaração das variáveis
    double altura, peso_ideal;
    char sexo;

    // Solicita a entrada do usuário
    printf("Altura (metros): ");
    scanf("%lf", &altura);
    printf("Sexo (M/F): ");
    scanf(" %c", &sexo);

    // Verifica o sexo e calcula o peso ideal
    if (sexo == 'm' || sexo == 'M') {
        peso_ideal = (72.7 * altura) - 58;
    } else if (sexo == 'f' || sexo == 'F') {
        peso_ideal = (62.1 * altura) - 44.7;
    } else {
        printf("Sexo inválido. Por favor, insira 'M' para masculino ou 'F' para feminino.\n");
        return 1; // Encerra o programa com código de erro
    }

    // Exibe o peso ideal
    printf("Peso ideal: %.1lf kg\n", peso_ideal);

    return 0;
}

Neste código, as funções de entrada e saída padrão da linguagem C (printf e scanf) são usadas para interagir com o usuário. A lógica do programa permanece a mesma que a versão em C++, apenas a sintaxe e as funções de entrada/saída são diferentes.

Exemplo em Pascal / Delphi / Lazarus

{

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

}
program CalculoPesoIdeal;

var
  altura, peso_ideal: real;
  sexo: char;

begin
  // Solicita a entrada do usuário
  write('Altura (metros): ');
  readln(altura);
  write('Sexo (M/F): ');
  readln(sexo);

  // Verifica o sexo e calcula o peso ideal
  if (sexo = 'm') or (sexo = 'M') then
    peso_ideal := (72.7 * altura) - 58
  else if (sexo = 'f') or (sexo = 'F') then
    peso_ideal := (62.1 * altura) - 44.7
  else
  begin
    writeln('Sexo inválido. Por favor, insira ''M'' para masculino ou ''F'' para feminino.');
    halt(1); // Encerra o programa com código de erro
  end;

  // Exibe o peso ideal
  writeln('Peso ideal: ', peso_ideal:0:1, ' kg');
end.

Este código em Pascal realiza a mesma função que as versões anteriores. Ele solicita a altura e o sexo do usuário, calcula o peso ideal com base nas fórmulas fornecidas e exibe o resultado. A estrutura geral do programa é semelhante à dos exemplos anteriores, mas adaptada à sintaxe e às construções da linguagem Pascal.

A estratégia utilizada para escrever o programa em Pascal foi:

1. Declaração de variáveis: Inicialmente, as variáveis necessárias foram declaradas, incluindo altura, peso_ideal e sexo.
2. Entrada de dados: O programa solicita ao usuário que insira a altura e o sexo. Isso é feito usando a função write para exibir mensagens no console e readln para ler as entradas do usuário.
3. Cálculo do peso ideal: Com base no sexo fornecido pelo usuário, o programa calcula o peso ideal usando as fórmulas específicas para homens e mulheres.
4. Verificação do sexo: O programa utiliza uma estrutura condicional (if-else if-else) para verificar se o sexo fornecido é válido (‘M’ ou ‘F’). Se o sexo não for válido, uma mensagem de erro é exibida e o programa é encerrado.
5. Exibição do resultado: Por fim, o programa exibe o peso ideal calculado usando a função writeln.

Exemplo em Python

'''

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

'''
# Solicita a entrada do usuário
altura = float(input("Altura (metros): "))
sexo = input("Sexo (M/F): ").lower()  # Converte para minúsculo para facilitar a comparação

# Verifica o sexo e calcula o peso ideal
if sexo == 'm':
    peso_ideal = (72.7 * altura) - 58
elif sexo == 'f':
    peso_ideal = (62.1 * altura) - 44.7
else:
    print("Sexo inválido. Por favor, insira 'M' para masculino ou 'F' para feminino.")
    exit(1)  # Encerra o programa com código de erro

# Exibe o peso ideal
print(f"Peso ideal: {peso_ideal:.1f} kg")

Este código em Python realiza as mesmas operações que os exemplos anteriores. Ele solicita a altura e o sexo do usuário, calcula o peso ideal com base nas fórmulas fornecidas e exibe o resultado. A estrutura geral do programa é semelhante à dos exemplos anteriores, mas adaptada à sintaxe e às construções da linguagem Python.

Exemplo em C# / C Sharp

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

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*******************************************************************************/
using System;

class Program
{
    static void Main(string[] args)
    {
        // Solicita a entrada do usuário
        Console.Write("Altura (metros): ");
        double altura = Convert.ToDouble(Console.ReadLine());
        Console.Write("Sexo (M/F): ");
        char sexo = Char.ToLower(Convert.ToChar(Console.ReadLine()));

        // Verifica o sexo e calcula o peso ideal
        double peso_ideal;
        if (sexo == 'm')
        {
            peso_ideal = (72.7 * altura) - 58;
        }
        else if (sexo == 'f')
        {
            peso_ideal = (62.1 * altura) - 44.7;
        }
        else
        {
            Console.WriteLine("Sexo inválido. Por favor, insira 'M' para masculino ou 'F' para feminino.");
            return; // Encerra o programa
        }

        // Exibe o peso ideal
        Console.WriteLine("Peso ideal: {0:f1} kg", peso_ideal);
    }
}

Este código em C# realiza as mesmas operações que os exemplos anteriores. Ele solicita a altura e o sexo do usuário, calcula o peso ideal com base nas fórmulas fornecidas e exibe o resultado. A estrutura geral do programa é semelhante à dos exemplos anteriores, mas adaptada à sintaxe e às construções da linguagem C#.

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) {
        // Cria um objeto Scanner para obter entrada do usuário
        Scanner scanner = new Scanner(System.in);

        // Solicita a entrada do usuário
        System.out.print("Altura (metros): ");
        double altura = scanner.nextDouble();
        System.out.print("Sexo (M/F): ");
        char sexo = scanner.next().charAt(0);
        sexo = Character.toLowerCase(sexo); // Converte para minúsculo para facilitar a comparação

        // Verifica o sexo e calcula o peso ideal
        double pesoIdeal;
        if (sexo == 'm') {
            pesoIdeal = (72.7 * altura) - 58;
        } else if (sexo == 'f') {
            pesoIdeal = (62.1 * altura) - 44.7;
        } else {
            System.out.println("Sexo inválido. Por favor, insira 'M' para masculino ou 'F' para feminino.");
            scanner.close();
            return; // Encerra o programa
        }

        // Exibe o peso ideal
        System.out.printf("Peso ideal: %.1f kg%n", pesoIdeal);

        // Fecha o Scanner para evitar vazamento de recursos
        scanner.close();
    }
}

Este programa em Java realiza as mesmas operações que os exemplos anteriores. Ele solicita a altura e o sexo do usuário, calcula o peso ideal com base nas fórmulas fornecidas e exibe o resultado. A estrutura geral do programa é semelhante à dos exemplos anteriores, mas adaptada à sintaxe e às construções da linguagem Java.

Exemplo em Rust

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

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*******************************************************************************/
use std::io;

fn main() {
    // Solicita a entrada do usuário
    println!("Altura (metros): ");
    let mut altura = String::new();
    io::stdin().read_line(&mut altura).expect("Falha ao ler a entrada");
    let altura: f64 = altura.trim().parse().expect("Valor inválido");

    println!("Sexo (M/F): ");
    let mut sexo = String::new();
    io::stdin().read_line(&mut sexo).expect("Falha ao ler a entrada");
    let sexo: char = sexo.trim().chars().next().expect("Valor inválido");

    // Verifica o sexo e calcula o peso ideal
    let peso_ideal: f64;
    match sexo {
        'm' | 'M' => {
            peso_ideal = (72.7 * altura) - 58.0;
        }
        'f' | 'F' => {
            peso_ideal = (62.1 * altura) - 44.7;
        }
        _ => {
            println!("Sexo inválido. Por favor, insira 'M' para masculino ou 'F' para feminino.");
            return; // Encerra o programa
        }
    }

    // Exibe o peso ideal
    println!("Peso ideal: {:.1} kg", peso_ideal);
}

Este programa em Rust realiza as mesmas operações que os exemplos anteriores. Ele solicita a altura e o sexo do usuário, calcula o peso ideal com base nas fórmulas fornecidas e exibe o resultado. A estrutura geral do programa é semelhante à dos exemplos anteriores, mas adaptada à sintaxe e às construções da linguagem Rust.

Exemplo em Go

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

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*******************************************************************************/
package main

import (
    "fmt"
)

func main() {
    // Solicita a entrada do usuário
    var altura float64
    var sexo string

    fmt.Print("Altura (metros): ")
    fmt.Scanln(&altura)
    fmt.Print("Sexo (M/F): ")
    fmt.Scanln(&sexo)

    // Verifica o sexo e calcula o peso ideal
    var pesoIdeal float64
    switch sexo {
    case "M", "m":
        pesoIdeal = (72.7 * altura) - 58.0
    case "F", "f":
        pesoIdeal = (62.1 * altura) - 44.7
    default:
        fmt.Println("Sexo inválido. Por favor, insira 'M' para masculino ou 'F' para feminino.")
        return // Encerra o programa
    }

    // Exibe o peso ideal
    fmt.Printf("Peso ideal: %.1f kg\n", pesoIdeal)
}

Este programa em Go realiza as mesmas operações que os exemplos anteriores. Ele solicita a altura e o sexo do usuário, calcula o peso ideal com base nas fórmulas fornecidas e exibe o resultado. A estrutura geral do programa é semelhante à dos exemplos anteriores, mas adaptada à sintaxe e às construções da linguagem Go.

Conclusão

Este exercício foi uma oportunidade valiosa para praticar e comparar a implementação de um programa simples em várias linguagens de programação, incluindo C++, C, Pascal, Python, Java, Rust e Go. Durante o exercício, pudemos observar as diferentes sintaxes, estruturas de controle e abordagens para manipulação de entrada/saída em cada linguagem.

Ao escrever o programa em diferentes linguagens, pudemos destacar as semelhanças e diferenças entre elas, bem como entender como conceitos fundamentais de programação são expressos em diferentes ambientes de desenvolvimento.

Além disso, este exercício nos permitiu praticar habilidades como manipulação de entrada/saída, uso de estruturas de controle, realização de cálculos simples e formatação de saída. Também lidamos com casos de entrada inválida, aprendendo a gerenciar erros e exceções de forma adequada em cada linguagem.

Em conclusão, este exercício foi uma excelente maneira de ampliar nosso conhecimento e habilidades em programação, enquanto nos familiarizamos com uma variedade de linguagens de programação. Isso nos prepara para enfrentar uma variedade de problemas e projetos futuros, independentemente da linguagem de programação utilizada.

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!

#DesenvolvimentoDeSoftware

#Programação

#LinguagensDeProgramação

#AprendizadoDeMáquina

#Algoritmos

#GiovaniDaCruz