1
resposta

Desafio: Simulador de pedidos em uma cafeteria

Dados necessários:
Quantidade de itens do pedido
Nome de cada item
Preço de cada item
Informação se o cliente é cadastrado

Variáveis utilizadas:
quantidadeItens
nomeItem
precoItem
totalCompra
desconto
valorFinal
clienteCadastrado

Algoritmo:
Iniciar o sistema
Criar a variável “totalCompra” e definir seu valor inicial como 0
Solicitar ao atendente a quantidade de itens do pedido
Ler a quantidade informada
Repetir o processo para cada item:
Solicitar o nome do item
Ler o nome informado
Solicitar o preço do item
Ler o preço informado
Somar o preço do item ao total da compra
Após registrar todos os itens:
Perguntar se o cliente é cadastrado
Ler a resposta informada
Verificar:
Se o cliente for cadastrado:
Calcular 10% de desconto

desconto=totalCompra×0.10

Calcular o valor final:

valorFinal=totalCompra−desconto

Exibir o valor com desconto
Caso o cliente não seja cadastrado:
Exibir o valor total da compra sem desconto
Encerrar o sistema

1 resposta

Olá, Rafaela! Como vai?

Parabéns por resolver mais um desafio com maestria! O seu algoritmo para o simulador da cafeteria ficou simplesmente espetacular. A estrutura está muito bem amarrada, cobrindo o ciclo completo que um software comercial precisa realizar.

Gostaria de destacar um avanço gigante que você trouxe neste algoritmo em relação aos anteriores: o uso de um Laço de Repetição (loop), representado pelo trecho "Repetir o processo para cada item".


Por que a sua lógica estrutural ficou excelente?

Muitos programadores iniciantes tentam resolver esse tipo de problema criando variáveis fixas (como preco_item1, preco_item2), o que limita o programa. Ao introduzir um laço de repetição, você tornou o seu sistema dinâmico: ele funciona perfeitamente se o cliente pedir um café expresso ou se ele fizer um pedido gigante com 50 itens para uma empresa.

Além disso, você utilizou a variável totalCompra como um Acumulador. A cada repetição do laço, o programa "lembra" do valor anterior e soma o preço do novo produto à sacola, o que é a base da lógica de carrinhos de compras em e-commerce.


Visualizando o Fluxo do Sistema

O seu algoritmo combina dois conceitos fundamentais da programação: a iteração (o laço que repete) e a condicional (o teste do desconto no final). Podemos visualizar essa esteira de processamento no seguinte mapa:


Próximo Passo: Traduzindo para Pseudocódigo

Como a sua lógica em linguagem natural já trouxe até as fórmulas matemáticas de forma limpa, a transição para um pseudocódigo estruturado fica muito fluida. Veja como o seu roteiro se transforma em instruções de máquina:

{
    // Inicialização
    totalCompra = 0;
    
    Escreva("Digite a quantidade de itens do pedido:");
    Leia(quantidadeItens);
    
    // Laço de Repetição (Loop) para acumular os valores
    Para (i = 1; i <= quantidadeItens; i++) 
    {
        Escreva("Digite o nome do item ", i, ":");
        Leia(nomeItem);
        
        Escreva("Digite o preço do item ", i, ":");
        Leia(precoItem);
        
        // Acumulador somando o preço atual ao total
        totalCompra = totalCompra + precoItem;
    }
    
    // Camada de Tomada de Decisão (Condicional)
    Escreva("O cliente é cadastrado no programa de fidelidade? (Sim/Não):");
    Leia(clienteCadastrado);
    
    Se (clienteCadastrado == "Sim") 
    {
        desconto = totalCompra * 0.10;
        valorFinal = totalCompra - desconto;
        Escreva("Cliente cadastrado! Valor final com 10% de desconto: R$ ", valorFinal);
    }
    Senão 
    {
        Escreva("Valor final da compra: R$ ", totalCompra);
    }
    
    Encerrar_Sistema;
}

Você fechou o capítulo com chave de ouro, demonstrando domínio sobre variáveis, acumuladores, laços de repetição e condicionais. Excelente trabalho, Rafaela! Continue firme nessa jornada de lógica de programação.

Espero que possa ter lhe ajudado!