Faça um programa para uma loja que vende dois tipos de sapatos, cabedal e sport. Cada sapato de cabedal custa 4000 , sport tem o preço unitário de 900 mt . Clientes que compram mais de 10 sapatos do tipo sport, pagam 600 mr por cada. Por outro lado, na compra de acima de 4 sapato de cabedal paga 3000 por cada. O programa deve pedir que o utilizador escolha o tipo de sapato que deseja comprar, e, na saida deve extiir o valor a pagar pelo número de sapatos comprados por cada cliente. Se o utlizador desejar terminar o programa, devera visualizar o valor total de todos os sapatos comprados. [7.0 v]
Passo 1
O enunciado pede um programa para uma loja que vende dois tipos de sapatos: cabedal e sport. Precisamos interagir com o utilizador (cliente) repetidamente, permitindo que cada cliente escolha um tipo de sapato e o número de pares que vai comprar, calcular o valor a pagar desse cliente e, quando o utilizador decidir terminar o programa, mostrar o valor total acumulado de todos os sapatos vendidos.
Informações dadas (vou listar todas exatamente):
- Preço unitário do sapato do tipo cabedal:
. - Preço unitário do sapato do tipo sport:
. - Regra de desconto para sport: se o cliente compra mais de
pares de sport, o preço passa a por par. - Regra de desconto para cabedal: se o cliente compra mais de
pares de cabedal, o preço passa a por par. - O programa deve pedir ao utilizador que escolha o tipo de sapato e a quantidade e, para cada cliente, exibir o valor a pagar.
- Se o utilizador desejar terminar o programa, deve visualizar o valor total de todos os sapatos comprados (soma de todas as vendas realizadas enquanto o programa rodou).
Passo 2
Definição das variáveis que vamos usar (explicando cada uma com calma):
- total_acumulado: variável que guarda a soma de todas as vendas já realizadas. Começa em
. - tipo: variável que guarda a escolha do tipo de sapato feita pelo utilizador (por exemplo:
para cabedal, para sport, para terminar). - quantidade: número de pares que o cliente quer comprar (inteiro e não negativo).
- preco_unitario: preço aplicado ao tipo escolhido após verificar se há desconto.
- valor_cliente: resultado de multiplicar o preço unitário pela quantidade — é o que o cliente vai pagar nessa compra.
Explicação rápida do que faz cada uma na prática:
- Enquanto o programa roda, para cada cliente lemos o tipo e a quantidade, calculamos preco_unitario com base nas regras e então fazemos:
- Depois adicionamos:
Passo 3
Como decidir o preço unitário (a “fórmula” das condições). Vou escrever as regras como expressões lógicas bem claras:
Para o tipo sport:
Para o tipo cabedal:
Explicando em palavras: primeiro verifico qual é o tipo pedido; depois verifico se a quantidade ultrapassa o limite de desconto daquele tipo; se ultrapassa aplico o preço com desconto, senão aplico o preço normal.]
Passo 4
Explicação de como calcular o valor a pagar passo a passo com um exemplo concreto (para você praticar a ideia):
- Exemplo A: cliente escolhe sport e quer
pares. - Como
, aplicamos preço unitário . - Valor do cliente:
.
- Como
- Exemplo B: cliente escolhe cabedal e quer
pares. - Como
, aplicamos preço unitário . - Valor do cliente:
.
- Como
Observação: nesses exemplos eu usei multiplicação direta; na prova você pode fazer à mão sem calculadora se os números forem pequenos, ou mostrar apenas a expressão e o resultado exato como acima.
Passo 5
Estrutura geral do programa (fluxo) — isto é o que você tem que implementar na prova:
- Inicializar
. - Repetir:
- Pedir ao utilizador que escolha o tipo: ex.: mostrar opções “1 - cabedal”, “2 - sport”, “0 - terminar”.
- Se o utilizador escolher
, sair do ciclo e ir para o passo 3. - Senão, pedir a quantidade de pares (inteiro).
- Validar a quantidade (tem de ser número inteiro maior ou igual a
; se inválido, pedir novamente ou mostrar erro). - Calcular
conforme as regras do Passo 3. - Calcular
. - Mostrar ao utilizador o
(o que ele tem de pagar). - Atualizar
.
- Quando o utilizador terminar (escolheu
), mostrar .
Observação de implementação: esse é um padrão clássico de “loop com sentinel” (sentinela
para terminar). Em prova, descreva esse fluxo e depois escreva o código correspondente.
Passo 6
Validação de entradas e detalhes práticos importantes (o que costuma cair em prova e o que eu recomendo fazer):
- Validar tipo: aceitar apenas
, ou . Se o utilizador digitar outra coisa, mostrar mensagem e pedir novamente. - Validar quantidade: aceitar apenas inteiros
. Não aceitar números negativos ou strings não numéricas. - Tratar o caso quantidade
: o valor do cliente será ; podemos aceitar isso e apenas não somar nada. - Sempre mostrar para o utilizador o preço unitário aplicado (opcional, mas ajuda em transparência).
- Usar variáveis inteiras para valores monetários evita problemas de precisão com floats.
Passo 7
Exemplo de interação completa (simulada) para consolidar:
- total_acumulado começa em
. - Cliente 1: escolhe cabedal (
), quantidade . - Como
, preco_unitario . - valor_cliente
. - Mostrar “Valor a pagar: 15000”.
- total_acumulado passa a
.
- Como
- Cliente 2: escolhe sport (
), quantidade . - Como
, preco_unitario . - valor_cliente
. - Mostrar “Valor a pagar: 7200”.
- total_acumulado passa a
.
- Como
- Cliente 3: escolhe sport (
), quantidade . - preco_unitario
. - valor_cliente
. - total_acumulado passa a
.
- preco_unitario
- Utilizador escolhe terminar (
). - Mostrar “Total acumulado de todas as vendas: 29400”.
Passo 8
Dicas para a prova (como escrever rápido e sem erros):
- Primeiro escreva o pseudocódigo/fluxo (Passo 5). Isso já garante a lógica.
- Depois escreva as verificações dos limites (
e ) exatamente como no enunciado — não troque os sinais. - Sempre atualize o acumulador depois de mostrar o valor ao cliente (ou antes; o importante é fazer apenas uma vez).
- Teste mentalmente com um caso simples (um cliente) e com vários clientes para ter certeza que o acumulador funciona.
- Se precisar entregar o código em linguagem específica, adapte apenas a sintaxe (a lógica não muda).
Resposta
# Programa loja de sapatos (cabedal e sport)
# Regras:
# - Cabedal: preco normal 4000, se quantidade > 4 preco = 3000
# - Sport: preco normal 900, se quantidade > 10 preco = 600
# - Entrada: tipo (1=cabedal, 2=sport, 0=terminar), quantidade (inteiro >=0)
# - Saida: valor a pagar por cliente; ao terminar, mostrar total acumulado
def ler_inteiro_prompt(prompt):
while True:
try:
valor = int(input(prompt))
return valor
except ValueError:
print("Entrada inválida. Digite um número inteiro.")
def main():
total_acumulado = 0
while True:
print("\nEscolha o tipo de sapato:")
print(" 1 - Cabedal")
print(" 2 - Sport")
print(" 0 - Terminar e mostrar total acumulado")
tipo = ler_inteiro_prompt("Digite a opção (0/1/2): ")
if tipo == 0:
# Termina o programa e mostra o total acumulado
print(f"\nTotal acumulado de todas as vendas: {total_acumulado}")
break
if tipo not in (1, 2):
print("Opção inválida. Por favor escolha 0, 1 ou 2.")
continue
quantidade = ler_inteiro_prompt("Digite a quantidade de pares (inteiro >= 0): ")
if quantidade < 0:
print("Quantidade inválida. Deve ser um inteiro maior ou igual a 0.")
continue
# Determina o preço unitário conforme o tipo e a quantidade
if tipo == 2: # Sport
if quantidade > 10:
preco_unitario = 600
else:
preco_unitario = 900
nome_tipo = "Sport"
else: # tipo == 1, Cabedal
if quantidade > 4:
preco_unitario = 3000
else:
preco_unitario = 4000
nome_tipo = "Cabedal"
valor_cliente = preco_unitario * quantidade
# Mostra o valor a pagar para o cliente atual
print(f"\nTipo: {nome_tipo}")
print(f"Preço unitário aplicado: {preco_unitario}")
print(f"Quantidade: {quantidade}")
print(f"Valor a pagar por este cliente: {valor_cliente}")
# Atualiza o total acumulado
total_acumulado += valor_cliente
if __name__ == "__main__":
main()