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: 4000.
  • Preço unitário do sapato do tipo sport: 900.
  • Regra de desconto para sport: se o cliente compra mais de 10 pares de sport, o preço passa a 600 por par.
  • Regra de desconto para cabedal: se o cliente compra mais de 4 pares de cabedal, o preço passa a 3000 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 0.
  • tipo: variável que guarda a escolha do tipo de sapato feita pelo utilizador (por exemplo: 1 para cabedal, 2 para sport, 0 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:
\text{valor\_cliente} = \text{preco\_unitario} \times \text{quantidade}.
  • Depois adicionamos:
\text{total\_acumulado} \leftarrow \text{total\_acumulado} + \text{valor\_cliente}.

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:
\text{preco\_unitario} = \begin{cases} 600, & \text{se }\text{quantidade} > 10,\\[4pt] 900, & \text{caso contrário.} \end{cases}á
Para o tipo cabedal:
\text{preco\_unitario} = \begin{cases} 3000, & \text{se }\text{quantidade} > 4,\\[4pt] 4000, & \text{caso contrário.} \end{cases}á
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 12 pares.
    • Como 12 > 10, aplicamos preço unitário 600.
    • Valor do cliente: 600 \times 12 = 7200.
  • Exemplo B: cliente escolhe cabedal e quer 3 pares.
    • Como 3 \le 4, aplicamos preço unitário 4000.
    • Valor do cliente: 4000 \times 3 = 12000.
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:
  1. Inicializar \text{total\_acumulado} \leftarrow 0.
  2. Repetir:
    • Pedir ao utilizador que escolha o tipo: ex.: mostrar opções “1 - cabedal”, “2 - sport”, “0 - terminar”.
    • Se o utilizador escolher 0, 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 0; se inválido, pedir novamente ou mostrar erro).
    • Calcular \text{preco\_unitario} conforme as regras do Passo 3.
    • Calcular \text{valor\_cliente} = \text{preco\_unitario} \times \text{quantidade}.
    • Mostrar ao utilizador o \text{valor\_cliente} (o que ele tem de pagar).
    • Atualizar \text{total\_acumulado} \leftarrow \text{total\_acumulado} + \text{valor\_cliente}.
  3. Quando o utilizador terminar (escolheu 0), mostrar \text{total\_acumulado}.
Observação de implementação: esse é um padrão clássico de “loop com sentinel” (sentinela 0 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 0, 1 ou 2. Se o utilizador digitar outra coisa, mostrar mensagem e pedir novamente.
  • Validar quantidade: aceitar apenas inteiros \ge 0. Não aceitar números negativos ou strings não numéricas.
  • Tratar o caso quantidade 0: o valor do cliente será 0; 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 0.
  • Cliente 1: escolhe cabedal ( 1), quantidade 5.
    • Como 5 > 4, preco_unitario = 3000.
    • valor_cliente = 3000 \times 5 = 15000.
    • Mostrar “Valor a pagar: 15000”.
    • total_acumulado passa a 0 + 15000 = 15000.
  • Cliente 2: escolhe sport ( 2), quantidade 8.
    • Como 8 \le 10, preco_unitario = 900.
    • valor_cliente = 900 \times 8 = 7200.
    • Mostrar “Valor a pagar: 7200”.
    • total_acumulado passa a 15000 + 7200 = 22200.
  • Cliente 3: escolhe sport ( 2), quantidade 12.
    • preco_unitario = 600.
    • valor_cliente = 600 \times 12 = 7200.
    • total_acumulado passa a 22200 + 7200 = 29400.
  • Utilizador escolhe terminar ( 0).
    • 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 ( >4 e >10) 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()

Exercícios relacionados