Exercício: valor a pagar num estacionamento por hora
Fala galera da programação, tudo beleza? Vamos a um novo exercício de algoritmos com desvio condicional. Desafie suas habilidades de programação com este exercício simples de cálculo de estacionamento em diversas linguagens! 🚗💻 Aprenda e pratique condicionais, entrada/saída e sintaxe em várias linguagens.
Dicas para o exercício
Lembrar que pode ser informado 0 no tempo e nesse caso nada é cobrado.
Exemplos:
1 hora = R$ 8;
2 horas = R$ 13;
3 horas = R$ 18;
Sugestão: Leia um numero inteiro correspondente as horas de estacionamento e escreva o valor que deve ser pago. Utilizar um comando condicional para calcular o valor a primeira hora e uma fórmula para calcular as demais.
O que podemos aprender neste exercício?
Lógica condicional: O problema envolve a utilização de lógica condicional para tomar decisões com base nas entradas do usuário.
Cálculos simples: O programa realiza cálculos simples para determinar o valor a ser pago com base no tempo de estacionamento fornecido pelo usuário.
Raciocínio lógico: Este exercício ajuda a praticar o raciocínio lógico ao lidar com diferentes cenários (tempo de estacionamento igual a 0, igual a 1 ou maior que 1).
Interação com o usuário: O programa solicita informações ao usuário e fornece resultados claros e compreensíveis.
Abstração de problemas reais para código: Este problema é um exemplo de como podemos traduzir um problema do mundo real (cobrança de estacionamento) em código de computador.
Prática de sintaxe de programação: Ajuda a praticar a sintaxe de programação, incluindo entrada e saída de dados, declaração de variáveis, uso de condicionais, etc.
Vamos aos códigos!
Exemplo em Portugol – Portugol Studio
/*
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*/
programa {
funcao inicio() {
inteiro horas
real valor
escreva("Digite o tempo de estacionamento em horas: ")
leia(horas)
se (horas == 0) {
valor = 0
} senao se (horas == 1) {
valor = 8
} senao {
// Calcula o valor para as horas adicionais
valor = 8 + (horas - 1) * 5
}
escreva( "Valor a ser pago: R$ ", valor)
}
}
Este programa solicita ao usuário o tempo de estacionamento em horas. Em seguida, ele calcula o valor a ser pago de acordo com as regras fornecidas. Se o tempo for 0, nenhum valor é cobrado. Se for 1 hora, é cobrado o valor base de R$ 8. Para mais de 1 hora, é cobrado o valor base mais R$ 5 para cada hora adicional após a primeira.
Exemplo em C++
/******************************************************************************
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*******************************************************************************/
#include <iostream>
using namespace std;
int main() {
int horas;
float valor;
cout << "Digite o tempo de estacionamento em horas: ";
cin >> horas;
if (horas == 0) {
valor = 0;
} else if (horas == 1) {
valor = 8;
} else {
// Calcula o valor para as horas adicionais
valor = 8 + (horas - 1) * 5;
}
cout << "Valor a ser pago: R$ " << valor << endl;
return 0;
}
A estratégia utilizada foi a seguinte:
- O programa solicita ao usuário o tempo de estacionamento em horas.
- Em seguida, ele verifica se o tempo informado é igual a 0. Se for, define o valor a ser pago como 0, pois não há cobrança.
- Se o tempo for 1 hora, o programa define o valor a ser pago como R$ 8, que é o valor base.
- Se o tempo for maior que 1 hora, o programa calcula o valor a ser pago somando o valor base de R$ 8 com R$ 5 multiplicado pelo número de horas adicionais (horas – 1). Isso porque a primeira hora já foi cobrada pelo valor base.
- Por fim, o programa exibe o valor a ser pago ao usuário.
Exemplo em C
/******************************************************************************
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*******************************************************************************/
#include <stdio.h>
int main() {
int horas;
float valor;
printf("Digite o tempo de estacionamento em horas: ");
scanf("%d", &horas);
if (horas == 0) {
valor = 0;
} else if (horas == 1) {
valor = 8;
} else {
// Calcula o valor para as horas adicionais
valor = 8 + (horas - 1) * 5;
}
printf("Valor a ser pago: R$ %.2f\n", valor);
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 CalculoEstacionamento;
var
horas: integer;
valor: real;
begin
writeln('Digite o tempo de estacionamento em horas: ');
readln(horas);
if horas = 0 then
valor := 0
else if horas = 1 then
valor := 8
else
// Calcula o valor para as horas adicionais
valor := 8 + (horas - 1) * 5;
writeln('Valor a ser pago: R$ ', valor:0:2);
end.
Este programa tem a mesma lógica dos exemplo em C++ e C, solicita ao usuário o tempo de estacionamento em horas, lê esse valor e calcula o valor a ser pago com base nas regras fornecidas. Em seguida, ele exibe o valor a ser pago ao usuário.
Exemplo em Python
'''
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
'''
horas = int(input("Digite o tempo de estacionamento em horas: "))
if horas == 0:
valor = 0
elif horas == 1:
valor = 8
else:
valor = 8 + (horas - 1) * 5
print("Valor a ser pago: R$", valor)
Este programa solicita ao usuário o tempo de estacionamento em horas, lê esse valor e calcula o valor a ser pago com base nas regras fornecidas. Em seguida, ele exibe o valor a ser pago ao usuário. Python oferece estruturas de controle mais compactas, como a ausência de chaves e a identação significativa para delimitar blocos de código, tornando o código mais legível e conciso.
Exemplo em C#
/******************************************************************************
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*******************************************************************************/
using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Digite o tempo de estacionamento em horas: ");
int horas = Convert.ToInt32(Console.ReadLine());
float valor;
if (horas == 0)
{
valor = 0;
}
else if (horas == 1)
{
valor = 8;
}
else
{
// Calcula o valor para as horas adicionais
valor = 8 + (horas - 1) * 5;
}
Console.WriteLine("Valor a ser pago: R$ " + valor);
}
}
Este programa em C# funciona de maneira semelhante aos programas em C e C++, mas utiliza as funcionalidades da linguagem C#. Ele solicita ao usuário o tempo de estacionamento em horas, lê esse valor e calcula o valor a ser pago com base nas regras fornecidas. Em seguida, ele exibe o valor a ser pago ao usuário.
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.println("Digite o tempo de estacionamento em horas: ");
int horas = scanner.nextInt();
float valor;
if (horas == 0) {
valor = 0;
} else if (horas == 1) {
valor = 8;
} else {
// Calcula o valor para as horas adicionais
valor = 8 + (horas - 1) * 5;
}
System.out.println("Valor a ser pago: R$ " + valor);
}
}
Este programa em Java realiza as mesmas operações que os exemplos anteriores. Ele solicita ao usuário o tempo de estacionamento em horas, lê esse valor e calcula o valor a ser pago com base nas regras fornecidas. Em seguida, ele exibe o valor a ser pago ao usuário.
Exemplo em Rust
/******************************************************************************
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*******************************************************************************/
use std::io;
fn main() {
println!("Digite o tempo de estacionamento em horas: ");
let mut input = String::new();
io::stdin().read_line(&mut input).expect("Falha ao ler a entrada.");
let horas: u32 = input.trim().parse().expect("Por favor, insira um número válido.");
let mut valor: f32;
if horas == 0 {
valor = 0.0;
} else if horas == 1 {
valor = 8.0;
} else {
// Calcula o valor para as horas adicionais
valor = 8.0 + (horas - 1) as f32 * 5.0;
}
println!("Valor a ser pago: R$ {:.2}", valor);
}
O código em Rust solicita ao usuário o tempo de estacionamento em horas, lê a entrada do console e converte-a em um número inteiro. Em seguida, calcula o valor a ser pago com base nas regras fornecidas, considerando uma tarifa fixa para a primeira hora e um valor adicional para as horas subsequentes. O resultado é exibido na tela com duas casas decimais. O programa também trata possíveis erros de conversão da entrada do usuário para garantir que a operação ocorra sem problemas, utilizando o método expect().
Exemplo em Go
/******************************************************************************
Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br
*******************************************************************************/
package main
import (
"fmt"
)
func main() {
var horas int
var valor float64
fmt.Println("Digite o tempo de estacionamento em horas: ")
fmt.Scan(&horas)
if horas == 0 {
valor = 0
} else if horas == 1 {
valor = 8
} else {
// Calcula o valor para as horas adicionais
valor = 8 + float64(horas-1)*5
}
fmt.Printf("Valor a ser pago: R$ %.2f\n", valor)
}
No exemplo em Go, o programa solicita ao usuário o tempo de estacionamento em horas e lê a entrada do console usando fmt.Scan(). Em seguida, com base no tempo fornecido, calcula o valor a ser pago conforme as regras estipuladas, considerando uma tarifa fixa para a primeira hora e um valor adicional para as horas subsequentes. O resultado é exibido na tela com duas casas decimais usando fmt.Printf().
Conclusão
Este exercício demonstrou como implementar um programa simples para calcular o valor do estacionamento com base no tempo, seguindo regras específicas. Ao traduzir o problema do mundo real para código em diversas linguagens de programação, pudemos observar diferentes abordagens e sintaxes, destacando as características individuais de cada linguagem. Além disso, praticamos conceitos fundamentais de lógica de programação, como estruturas condicionais e cálculos simples, reforçando a compreensão desses conceitos e a habilidade de resolver problemas computacionais.
Beleza pessoal? Espero que tenham gostado.
Dúvidas ou sugestões? Deixe o seu comentário!
Um abraço e até o próximo post. Valeu!
#Desenvolvimento
#Programação
#Aprendizado
#DesvioCondicional
#Algoritmos
#GiovaniDaCruz
