Crie um algoritmo e um programa em que leia 4 valores, Hi, Mi, Hf, Mf, representando respectivamente a hora e minuto inicial e final de um evento, e calcule a duração do mesmo em horas e minutos. Considere que o evento pode iniciar em um dia e terminar no dia seguinte.

Fala galera da programação, tudo beleza? 💻 Novo exercício na área para aprimorar a nossa lógica de programação.

Dica do exercício:

Para simplificar o problema, converta cada par de valores em um único valor em minutos. 🕒

O que podemos aprender neste exercício?

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

1. Manipulação de Entrada/Saída: Aprendemos como ler dados de entrada do usuário e exibir resultados na saída usando diferentes linguagens de programação.
2. Conversão de Tipos: Vimos como converter strings em valores numéricos adequados para cálculos, uma habilidade crucial ao lidar com entrada do usuário.
3. Cálculos Básicos: Praticamos realizar cálculos simples para resolver um problema específico, como converter horas e minutos em minutos totais e calcular a diferença entre dois horários.
4. Controle de Fluxo: Utilizamos estruturas de controle de fluxo, como condicionais, para lidar com diferentes cenários, como quando o evento se estende para o dia seguinte.
5. Sintaxe e Semântica: Comparamos a sintaxe e a semântica de diferentes linguagens de programação, observando suas similaridades e diferenças na implementação do mesmo problema.

Vamos aos códigos!

Exemplo em C++

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

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

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

using namespace std;

int main() {
    int Hi, Mi, Hf, Mf;
    int inicio_minutos, fim_minutos, duracao_minutos;

    // Leitura dos valores de entrada
    cout << "Digite a hora inicial (Hi Mi): ";
    cin >> Hi >> Mi;
    cout << "Digite a hora final (Hf Mf): ";
    cin >> Hf >> Mf;

    // Convertendo hora inicial e final para minutos
    inicio_minutos = Hi * 60 + Mi;
    fim_minutos = Hf * 60 + Mf;

    // Calculando a duração do evento em minutos
    if (fim_minutos > inicio_minutos) {
        duracao_minutos = fim_minutos - inicio_minutos;
    } else {
        duracao_minutos = (24 * 60 - inicio_minutos) + fim_minutos;
    }

    // Convertendo a duração de minutos para horas e minutos
    int duracao_horas = duracao_minutos / 60;
    int duracao_minutos_resto = duracao_minutos % 60;

    // Exibindo o resultado
    cout << "A duração do evento é de " << duracao_horas << " horas e " << duracao_minutos_resto << " minutos." << endl;

    return 0;
}

Esse programa lê os valores de entrada representando a hora e minuto inicial (Hi, Mi) e a hora e minuto final (Hf, Mf) do evento. Em seguida, converte esses valores para minutos, calcula a duração do evento em minutos e, por fim, converte a duração de volta para horas e minutos, exibindo o resultado.

A estratégia utilizada neste programa foi:

1. Ler os valores de entrada representando a hora e minuto inicial (Hi, Mi) e a hora e minuto final (Hf, Mf) do evento.
2. Converter esses valores de hora e minuto para minutos, para simplificar os cálculos.
3. Calcular a duração do evento em minutos, levando em consideração a possibilidade do evento começar em um dia e terminar no dia seguinte.
   • Se a hora final for maior que a hora inicial, a duração é simplesmente a diferença entre as duas.
   • Se a hora final for menor ou igual à hora inicial, a duração é a diferença entre 24 horas (1440 minutos) e a hora inicial, somada à hora final.
4. Converter a duração de minutos para horas e minutos.
5. Exibir o resultado.

Exemplo em C

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

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

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

int main() {
    int Hi, Mi, Hf, Mf;
    int inicio_minutos, fim_minutos, duracao_minutos;

    // Leitura dos valores de entrada
    printf("Digite a hora inicial (Hi Mi): ");
    scanf("%d %d", &Hi, &Mi);
    printf("Digite a hora final (Hf Mf): ");
    scanf("%d %d", &Hf, &Mf);

    // Convertendo hora inicial e final para minutos
    inicio_minutos = Hi * 60 + Mi;
    fim_minutos = Hf * 60 + Mf;

    // Calculando a duração do evento em minutos
    if (fim_minutos > inicio_minutos) {
        duracao_minutos = fim_minutos - inicio_minutos;
    } else {
        duracao_minutos = (24 * 60 - inicio_minutos) + fim_minutos;
    }

    // Convertendo a duração de minutos para horas e minutos
    int duracao_horas = duracao_minutos / 60;
    int duracao_minutos_resto = duracao_minutos % 60;

    // Exibindo o resultado
    printf("A duração do evento é de %d horas e %d minutos.\n", duracao_horas, duracao_minutos_resto);

    return 0;
}

Este programa em C faz exatamente a mesma coisa que o programa em C++. Ele lê os valores de entrada, realiza os cálculos e exibe o resultado. Enquanto C++ usa cout e cin, C usa printf e scanf para entrada/saída.

Exemplo em Pascal / Delphi / Lazarus

{

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

}
program CalculaDuracaoEvento;
var
  Hi, Mi, Hf, Mf: Integer;
  inicio_minutos, fim_minutos, duracao_minutos: Integer;
  duracao_horas, duracao_minutos_resto: Integer;
begin
  // Leitura dos valores de entrada
  Write('Digite a hora inicial (Hi Mi): ');
  Readln(Hi, Mi);
  Write('Digite a hora final (Hf Mf): ');
  Readln(Hf, Mf);

  // Convertendo hora inicial e final para minutos
  inicio_minutos := Hi * 60 + Mi;
  fim_minutos := Hf * 60 + Mf;

  // Calculando a duração do evento em minutos
  if fim_minutos > inicio_minutos then
    duracao_minutos := fim_minutos - inicio_minutos
  else
    duracao_minutos := (24 * 60 - inicio_minutos) + fim_minutos;

  // Convertendo a duração de minutos para horas e minutos
  duracao_horas := duracao_minutos div 60;
  duracao_minutos_resto := duracao_minutos mod 60;

  // Exibindo o resultado
  WriteLn('A duração do evento é de ', duracao_horas, ' horas e ', duracao_minutos_resto, ' minutos.');
end.

Este programa em Pascal realiza as mesmas operações que os programas anteriores, lendo os valores de entrada, calculando a duração do evento e exibindo o resultado. Em Pascal, a entrada é feita usando Readln e a saída usando Write ou WriteLn. A declaração de variáveis vem antes do bloco principal do programa.

Exemplo em Python

'''

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

'''
# Leitura dos valores de entrada
Hi, Mi = map(int, input("Digite a hora inicial (Hi Mi): ").split())
Hf, Mf = map(int, input("Digite a hora final (Hf Mf): ").split())

# Convertendo hora inicial e final para minutos
inicio_minutos = Hi * 60 + Mi
fim_minutos = Hf * 60 + Mf

# Calculando a duração do evento em minutos
if fim_minutos > inicio_minutos:
    duracao_minutos = fim_minutos - inicio_minutos
else:
    duracao_minutos = (24 * 60 - inicio_minutos) + fim_minutos

# Convertendo a duração de minutos para horas e minutos
duracao_horas = duracao_minutos // 60
duracao_minutos_resto = duracao_minutos % 60

# Exibindo o resultado
print("A duração do evento é de", duracao_horas, "horas e", duracao_minutos_resto, "minutos.")

Este programa em Python realiza as mesmas operações que os programas anteriores, lendo os valores de entrada, calculando a duração do evento e exibindo o resultado. Python é uma linguagem de alto nível, por isso não há necessidade de declaração de tipo de variável e a sintaxe é mais simplificada em comparação com C e Pascal.

Exemplo em C# / C Sharp

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

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

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

class Program
{
    static void Main()
    {
        // Leitura dos valores de entrada
        Console.Write("Digite a hora inicial (Hi Mi): ");
        string[] inicio = Console.ReadLine().Split();
        int Hi = int.Parse(inicio[0]);
        int Mi = int.Parse(inicio[1]);

        Console.Write("Digite a hora final (Hf Mf): ");
        string[] fim = Console.ReadLine().Split();
        int Hf = int.Parse(fim[0]);
        int Mf = int.Parse(fim[1]);

        // Convertendo hora inicial e final para minutos
        int inicio_minutos = Hi * 60 + Mi;
        int fim_minutos = Hf * 60 + Mf;

        // Calculando a duração do evento em minutos
        int duracao_minutos;
        if (fim_minutos > inicio_minutos)
            duracao_minutos = fim_minutos - inicio_minutos;
        else
            duracao_minutos = (24 * 60 - inicio_minutos) + fim_minutos;

        // Convertendo a duração de minutos para horas e minutos
        int duracao_horas = duracao_minutos / 60;
        int duracao_minutos_resto = duracao_minutos % 60;

        // Exibindo o resultado
        Console.WriteLine($"A duração do evento é de {duracao_horas} horas e {duracao_minutos_resto} minutos.");
    }
}

Este programa em C# realiza as mesmas operações que os programas anteriores, lendo os valores de entrada, calculando a duração do evento e exibindo o resultado. C# é uma linguagem fortemente tipada, então é necessário fazer a conversão explícita dos valores lidos para os tipos desejados.

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

        // Leitura dos valores de entrada
        System.out.print("Digite a hora inicial (Hi Mi): ");
        int Hi = scanner.nextInt();
        int Mi = scanner.nextInt();

        System.out.print("Digite a hora final (Hf Mf): ");
        int Hf = scanner.nextInt();
        int Mf = scanner.nextInt();

        // Convertendo hora inicial e final para minutos
        int inicio_minutos = Hi * 60 + Mi;
        int fim_minutos = Hf * 60 + Mf;

        // Calculando a duração do evento em minutos
        int duracao_minutos;
        if (fim_minutos > inicio_minutos)
            duracao_minutos = fim_minutos - inicio_minutos;
        else
            duracao_minutos = (24 * 60 - inicio_minutos) + fim_minutos;

        // Convertendo a duração de minutos para horas e minutos
        int duracao_horas = duracao_minutos / 60;
        int duracao_minutos_resto = duracao_minutos % 60;

        // Exibindo o resultado
        System.out.println("A duração do evento é de " + duracao_horas + " horas e " + duracao_minutos_resto + " minutos.");
        
        scanner.close();
    }
}

Este programa em Java realiza as mesmas operações que os programas anteriores, lendo os valores de entrada, calculando a duração do evento e exibindo o resultado. Java é uma linguagem fortemente tipada e orientada a objetos, então é necessário utilizar classes como Scanner para entrada de dados.

Exemplo em Rust

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

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

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

fn main() {
    // Leitura dos valores de entrada
    println!("Digite a hora inicial (Hi Mi): ");
    let mut inicio = String::new();
    io::stdin().read_line(&mut inicio).expect("Falha ao ler entrada.");
    let inicio: Vec<i32> = inicio.trim().split_whitespace()
                                .map(|x| x.parse().expect("Valor inválido."))
                                .collect();
    let Hi = inicio[0];
    let Mi = inicio[1];

    println!("Digite a hora final (Hf Mf): ");
    let mut fim = String::new();
    io::stdin().read_line(&mut fim).expect("Falha ao ler entrada.");
    let fim: Vec<i32> = fim.trim().split_whitespace()
                            .map(|x| x.parse().expect("Valor inválido."))
                            .collect();
    let Hf = fim[0];
    let Mf = fim[1];

    // Convertendo hora inicial e final para minutos
    let inicio_minutos = Hi * 60 + Mi;
    let fim_minutos = Hf * 60 + Mf;

    // Calculando a duração do evento em minutos
    let duracao_minutos = if fim_minutos > inicio_minutos {
        fim_minutos - inicio_minutos
    } else {
        (24 * 60 - inicio_minutos) + fim_minutos
    };

    // Convertendo a duração de minutos para horas e minutos
    let duracao_horas = duracao_minutos / 60;
    let duracao_minutos_resto = duracao_minutos % 60;

    // Exibindo o resultado
    println!("A duração do evento é de {} horas e {} minutos.", duracao_horas, duracao_minutos_resto);
}

Em Rust, a entrada é tratada usando a biblioteca padrão std::io, enquanto a conversão de tipos é mais explícita usando parse() e expect() para tratamento de erros. A linguagem enfatiza a segurança de memória e a prevenção de erros de tempo de execução.

Exemplo em Go

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

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

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

import (
    "fmt"
)

func main() {
    // Leitura dos valores de entrada
    var Hi, Mi, Hf, Mf int

    fmt.Print("Digite a hora inicial (Hi Mi): ")
    fmt.Scan(&Hi, &Mi)

    fmt.Print("Digite a hora final (Hf Mf): ")
    fmt.Scan(&Hf, &Mf)

    // Convertendo hora inicial e final para minutos
    inicioMinutos := Hi*60 + Mi
    fimMinutos := Hf*60 + Mf

    // Calculando a duração do evento em minutos
    var duracaoMinutos int
    if fimMinutos > inicioMinutos {
        duracaoMinutos = fimMinutos - inicioMinutos
    } else {
        duracaoMinutos = (24*60 - inicioMinutos) + fimMinutos
    }

    // Convertendo a duração de minutos para horas e minutos
    duracaoHoras := duracaoMinutos / 60
    duracaoMinutosResto := duracaoMinutos % 60

    // Exibindo o resultado
    fmt.Printf("A duração do evento é de %d horas e %d minutos.\n", duracaoHoras, duracaoMinutosResto)
}

Este programa em Go realiza as mesmas operações que os programas anteriores, lendo os valores de entrada, calculando a duração do evento e exibindo o resultado. Go é uma linguagem compilada, concorrente e de tipagem estática, e sua sintaxe é mais simples e concisa em comparação com algumas outras linguagens.

Conclusão

Neste exercício, exploramos como resolver um problema simples de cálculo de duração de evento em diferentes linguagens de programação, como C++, C, Pascal, Python, C#, Java, Rust e Go. Ao escrever e comparar as soluções em várias linguagens, pudemos observar as diferentes sintaxes, abordagens e características de cada uma. A prática nos permitiu entender melhor como lidar com entrada/saída, fazer cálculos básicos, controlar o fluxo do programa e manipular tipos de dados em cada linguagem.

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!

#Programação

#DesenvolvimentoDeSoftware

#LinguagensDeProgramação

#GiovaniDaCruz