Uma loja utiliza o código V para transação à vista e P para transação a prazo. Faça um programa que receba o código e o valor de quinze transações, calcule e mostre:
  • O valor total das compras à vista;
  • O valor total das compras a prazo;
  • O valor total das compras efetuadas; e
  • O valor da primeira prestação das compras a prazo juntas, sabendo-se que serão pagas em três vezes.

Passo 1

O que o problema pede e o que ele dá:
  • Pedidos:
    • Calcular o valor total das compras à vista.
    • Calcular o valor total das compras a prazo.
    • Calcular o valor total de todas as compras.
    • Calcular o valor da primeira prestação das compras a prazo juntas, sabendo que serão pagas em três vezes.
  • Dados fornecidos:
    • Serão lidos exatamente quinze transações.
    • Cada transação fornece: um código (que é ou V para à vista ou P para a prazo) e um valor numérico (o valor da transação).
  • Observações importantes que vou assumir (já que o enunciado normalmente assume entradas corretas):
    • Cada código será V ou P (podemos aceitar também v e p e normalizar).
    • Os valores são números positivos (podem ter centavos).
  • Resultado esperado: quatro números: total à vista, total a prazo, total geral, e primeira prestação (que é o total a prazo dividido por três).

Passo 2

Ideia geral do método (em palavras simples, passo a passo mental):
  • Vamos percorrer as 15 transações uma a uma.
  • Mantemos duas “caixinhas” onde vamos acumulando valores enquanto lemos: uma para as compras à vista e outra para as compras a prazo.
  • Para cada transação: leio o código e o valor; se o código for V eu somo o valor na caixinha “à vista”; se for P somo na caixinha “a prazo”.
  • Ao final das 15 leituras calculo o total geral somando as duas caixinhas.
  • Para obter a primeira prestação das compras a prazo, divido o total a prazo por 3.

Passo 3

Definindo variáveis e fórmulas (aqui explico como funcionam as contas, com notação):
  • Vou chamar de S_V o somatório das compras à vista (inicialmente zero).
  • Vou chamar de S_P o somatório das compras a prazo (inicialmente zero).
  • Para cada transação i (com código c_i e valor v_i):
    • Se c_i = V então aplicamos a atualização
    S_V := S_V + v_i
    • Se c_i = P então aplicamos a atualização
    S_P := S_P + v_i
  • Depois das quinze transações calculamos: S_T = S_V + S_Pe a primeira prestação das compras a prazo: P_1 = \frac{S_P}{3}
  • Explicando cada símbolo:
    • S_V é a soma acumulada das transações com código V.
    • S_P é a soma acumulada das transações com código P.
    • v_i é o valor numérico da i-ésima transação.
    • S_T é o total geral de todas as compras.
    • P_1 é o valor da primeira parcela (um terço do total a prazo).

Passo 4

Por que usar acumuladores e um laço (explicação didática):
  • Acumulador: é uma variável que começa em zero e vai somando pedaços à medida que processamos cada entrada. É a forma mais direta de obter um total sem guardar todas as transações.
  • Laço (loop): como temos um número fixo de leituras (15), usamos um laço que se repete 15 vezes. Em cada iteração lemos uma transação e atualizamos o acumulador correspondente.
  • Condicional (if/else): precisamos decidir para qual acumulador somar o valor, então usamos uma verificação do código da transação.
  • Essas três ideias (inicializar somas, repetir 15 vezes, checar código e somar) resolvem o problema de forma simples e rápida — ideal para fazer numa prova sem complicação.

Passo 5

Detalhes de implementação práticos que caem na prova:
  • Normalizar o código: ao ler o código, converta para maiúscula (por exemplo) para aceitar tanto v quanto V.
  • Tratar possíveis espaços: remova espaços antes e depois do código.
  • Formato de saída: como são valores monetários, mostre com duas casas decimais (por exemplo, R$ 123,45). Na prova, é comum pedir duas casas decimais; se não pedirem, é seguro usar duas casas.
  • Divisão por 3: ao dividir S_P por 3 pode aparecer dízima; arredonde para duas casas quando for imprimir.
  • Validação opcional: se quiser, você pode verificar se o código é diferente de V e P e então ignorar/contar como inválido — mas como o enunciado garante o enunciado bem formado, isso não é estritamente necessário.

Passo 6

Exemplo numérico (mini-simulação com poucas transações para entender):
  • Suponha que eu tenha 5 transações (apenas para demonstrar; o problema real usa 15). As transações (código, valor) são:
    1. (V, 100,50)
    2. (P, 60,00)
    3. (V, 40,00)
    4. (P, 30,25)
    5. (V, 10,00)
  • Fazendo passo a passo:
    • Inicialmente S_V=0,00 e S_P=0,00.
    • Transação 1: código V S_V := 0{,}00 + 100{,}50 = 100{,}50.
    • Transação 2: código P S_P := 0{,}00 + 60{,}00 = 60{,}00.
    • Transação 3: código V S_V := 100{,}50 + 40{,}00 = 140{,}50.
    • Transação 4: código P S_P := 60{,}00 + 30{,}25 = 90{,}25.
    • Transação 5: código V S_V := 140{,}50 + 10{,}00 = 150{,}50.
    • Total geral S_T = S_V + S_P = 150{,}50 + 90{,}25 = 240{,}75.
    • Primeira prestação P_1 = S_P/3 = 90{,}25/3 \approx 30{,}08333, arredondando para duas casas: 30{,}08.
  • Esse exemplo mostra concretamente como os acumuladores evoluem.

Passo 7

O que você deve implementar na prova (pseudocódigo para você transcrever rápido):
  • Inicialize S_V \leftarrow 0, S_P \leftarrow 0
  • Para i de 1 até 15 faça:
    • leia código c
    • leia valor v
    • transforme c para maiúscula e remova espaços
    • se c = V então S_V \leftarrow S_V + v senão (assumindo P) S_P \leftarrow S_P + v
  • Calcule S_T \leftarrow S_V + S_P
  • Calcule P_1 \leftarrow S_P / 3
  • Imprima S_V, S_P, S_T e P_1 formatados com duas casas decimais

Resposta

# Programa em Python para ler 15 transações e calcular os totais pedidos

S_V = 0.0  # soma das compras à vista
S_P = 0.0  # soma das compras a prazo

for i in range(15):
    codigo = input().strip().upper()       # lê o código (ex.: V ou P)
    valor = float(input().strip().replace(',', '.'))  # lê o valor; aceita vírgula como decimal
    if codigo == 'V':
        S_V += valor
    elif codigo == 'P':
        S_P += valor
    else:
        # Caso de código inválido: ignorar (não esperado segundo enunciado)
        pass

S_T = S_V + S_P
P_1 = S_P / 3.0

# Imprime resultados com duas casas decimais
print(f"{S_V:.2f}")
print(f"{S_P:.2f}")
print(f"{S_T:.2f}")
print(f"{P_1:.2f}")

Exercícios relacionados