01 / 19
Lógica de Programação · Sem 8 · Aula 2/2

Contar, Somar
e Parar

Os três padrões fundamentais para dominar o while: contador, acumulador e sentinela.

ProfessorGuilherme Antunes CursoEnsino Médio Técnico — Informática Duração100 minutos (2 aulas)
02 / 19
Recap + Objetivos

Hoje você vai.

Na aula passada você aprendeu o que é o while e como evitar loop infinito. Hoje vai dominar os 3 padrões que aparecem em quase todo programa real.

01

Usar um contador para saber quantas vezes o laço rodou

02

Usar um acumulador para somar valores a cada iteração

03

Usar uma sentinela para encerrar a leitura na hora certa

04

Combinar tudo em um programa real: total da compra com "sair"

03 / 19
Introdução · Analogia

O Caixa do Mercado 🛒

Você está no caixa rápido do supermercado. A operadora passa cada produto:

  • Conta quantos itens foram passados → contador
  • Soma o valor de cada um ao total da nota → acumulador
  • Para quando aparece o último item (ou você diz "fim") → sentinela

Os 3 padrões que vamos ver hoje estão todos no mesmo cupom fiscal.

CONSA MERCADO · Cupom
Pão francêsR$ 0,90
LeiteR$ 4,50
CaféR$ 12,80
AçúcarR$ 5,20
TOTALR$ 23,40
Itens: 4 · Cliente disse "fim"
04 / 19
Conceito 1

Contador

Variável numérica que conta quantas vezes o laço já foi executado.

  • A cada iteração, soma um valor fixo (quase sempre +1)
  • É como um cliquer manual de pessoas entrando num evento
  • Ajuda a controlar laços que precisam rodar um número exato de vezes
+1
a cada volta
05 / 19
Sintaxe · Contador

Como se escreve um contador?

Inicialize com 0 antes do laço; some +1 dentro do laço:

algoritmo "Contar"
var
   contador: inteiro
inicio
   contador <- 0
   enquanto contador < 5 faca
      escreval("Volta ", contador + 1)
      contador <- contador + 1
   fimenquanto
fimalgoritmo
contador = 0

while contador < 5:
    print("Volta", contador + 1)
    contador = contador + 1
    # ou: contador += 1
🧠 Atalho em Python: contador += 1 faz a mesma coisa que contador = contador + 1, só que mais curto.
06 / 19
Mão na massa · Prática

🟢 Praticar: Caixa Rápido

Fácil

Situação: o caixa rápido tem limite de 10 itens. Conte os itens passados e alerte se passar do limite.

algoritmo "CaixaRapido"
var
   contador: inteiro
inicio
   contador <- 0
   enquanto contador < 10 faca
      escreval("Item ", contador + 1)
      contador <- contador + 1
   fimenquanto
   escreval("Limite atingido!")
fimalgoritmo
contador = 0

while contador < 10:
    print("Item", contador + 1)
    contador += 1

print("Limite atingido!")
07 / 19
Conceito 2

Acumulador

Parecido com o contador, mas soma um valor variável a cada iteração — não um número fixo.

  • É o carrinho de compras: cada produto que entra tem um preço diferente, mas todos somam ao total
  • Perfeito para calcular somas, médias, totalizações
  • Sempre começa em 0 antes do laço
+R$
valor que muda
08 / 19
Sintaxe · Acumulador

Somando valores variáveis

O total começa em 0 e a cada iteração recebe total + valor_lido:

algoritmo "Somar3"
var
   total, valor: real
   contador: inteiro
inicio
   total <- 0
   contador <- 0
   enquanto contador < 3 faca
      escreva("Valor: ")
      leia(valor)
      total <- total + valor
      contador <- contador + 1
   fimenquanto
   escreval("Total: R$ ", total)
fimalgoritmo
total = 0
contador = 0

while contador < 3:
    valor = float(input("Valor: "))
    total = total + valor
    contador += 1

print("Total: R$", total)
09 / 19
Mão na massa · Prática

🟡 Praticar: Subtotal da Compra

Médio

Situação: escreva um programa que pede o preço de 3 produtos e mostra o subtotal da compra. Use um acumulador.

algoritmo "Subtotal"
var
   total, preco: real
   i: inteiro
inicio
   total <- 0
   i <- 1
   enquanto i <= 3 faca
      escreva("Preço do produto ", i, ": ")
      leia(preco)
      total <- total + preco
      i <- i + 1
   fimenquanto
   escreval("Subtotal: R$ ", total)
fimalgoritmo
total = 0
i = 1

while i <= 3:
    preco = float(input(f"Preço do produto {i}: "))
    total = total + preco
    i += 1

print("Subtotal: R$", total)
10 / 19
Conceito 3

Sentinela

Um valor especial combinado para marcar o fim da entrada de dados.

  • Útil quando não sabemos quantos dados o usuário vai digitar
  • Ex: ler notas até alguém digitar -1 → o -1 é a sentinela
  • Ex: ler mensagens até alguém digitar "sair" → "sair" é a sentinela
−1
valor que para o laço
11 / 19
Sintaxe · Sentinela

Chat que termina com "sair"

Lê a primeira mensagem antes do while; dentro do laço, lê a próxima:

algoritmo "Chat"
var
   msg: caractere
inicio
   escreval("Inicie a conversa (sair p/ encerrar):")
   leia(msg)
   enquanto msg <> "sair" faca
      escreval("Você disse: ", msg)
      escreval("Próxima:")
      leia(msg)
   fimenquanto
   escreval("Chat encerrado.")
fimalgoritmo
msg = input("Inicie a conversa (sair p/ encerrar): ")

while msg != "sair":
    print("Você disse:", msg)
    msg = input("Próxima: ")

print("Chat encerrado.")
🧠 Padrão "ler antes, ler dentro": a primeira leitura inicializa a variável; as próximas vão dentro do laço para que a condição possa mudar.
12 / 19
Pause e responda

Em um programa que soma o valor de uma compra…

…qual variável é o acumulador?

AVariável que conta quantos produtos foram incluídos
BVariável que guarda o nome do produto mais caro
CVariável que soma o preço de cada item ao total
DVariável que verifica se o usuário digitou "fim"

Discutam: qual é a diferença prática entre contador e acumulador?

13 / 19
Projeto Final · AP4

🔴 Desafio: Total da Compra

Desafio

Missão: construir um programa que lê o valor de cada item da compra e vai somando ao total. O programa deve parar quando o usuário digitar "sair" e então mostrar o total.

O programa precisa:

  • Perguntar o valor de cada item, um por um
  • Somar cada valor lido ao total da compra
  • Parar quando o usuário digitar a sentinela "sair"
  • Mostrar o total final da compra ao encerrar
🧠 Dica: esse desafio combina os padrões da aula — acumulador (soma os valores) e sentinela (a palavra "sair" encerra o laço).
14 / 19
Plano de ataque

5 passos para resolver

1

Declare as variáveis: total e entrada

2

Inicialize total = 0

3

Leia a primeira entrada antes do while

4

Enquanto entrada != "sair": converta p/ número, some ao total, leia próxima

5

Ao sair do laço, exiba o total da compra

⚠️ Cuidado: a entrada é lida como texto (para comparar com "sair"). Antes de somar, converta para número — em Python com float(entrada); em VisualG com caracpnum(entrada).
15 / 19
Resolução · AP4

Total da compra pronto ✅

algoritmo "TotalDaCompra"
var
   total: real
   entrada: caractere
inicio
   total <- 0
   escreval("Valor do item (sair p/ encerrar):")
   leia(entrada)
   enquanto entrada <> "sair" faca
      total <- total + caracpnum(entrada)
      escreval("Próximo item (sair p/ encerrar):")
      leia(entrada)
   fimenquanto
   escreval("Total da compra: R$ ", total)
fimalgoritmo
total = 0

entrada = input("Valor do item (sair p/ encerrar): ")

while entrada != "sair":
    total = total + float(entrada)
    entrada = input("Próximo item (sair p/ encerrar): ")

print(f"Total da compra: R$ {total:.2f}")
🧠 Repare: a mesma entrada serve para comparar com "sair" e para virar valor — é o padrão "ler antes, ler dentro" unindo acumulador + sentinela.
16 / 19
Encerramento

O que aprendemos hoje ✅

  • Contador → soma valor fixo (+1) para contar iterações
  • Acumulador → soma valor variável para totalizar
  • Sentinela → valor especial que termina o laço quando aparece
  • Padrão "ler antes, ler dentro" → garante que a condição possa mudar
  • Conversão de texto para número → ler como caractere para comparar com "sair", converter antes de somar
📚 Próxima semana

Atividades práticas avançadas — você vai criar programas completos juntando decisão (if) + repetição (while).

❓ Pergunta de fechamento

Dos três padrões (contador, acumulador, sentinela), qual fez mais sentido e qual ainda está embaralhado pra você?

17 / 19
Desafio bônus

🔴 Desafio: Calculadora de Média

Desafio

Missão: construir uma calculadora que lê quantas notas o usuário quiser e mostra a média da turma. O programa deve parar quando o usuário digitar -1.

O programa precisa:

  • Perguntar a nota de cada aluno, uma por uma
  • Parar quando o usuário digitar a sentinela -1
  • Mostrar o total de notas inseridas e a média geral
  • Tratar o caso especial: nenhuma nota digitada (não dividir por zero!)
🧠 Dica: esse desafio combina os 3 padrões da aula — contador (qtd de notas), acumulador (soma) e sentinela (-1).
18 / 19
Plano de ataque

5 passos para resolver

1

Declare 4 variáveis: soma, qtd, nota, media

2

Inicialize soma=0 e qtd=0

3

Leia a primeira nota antes do while

4

Enquanto nota != -1: acumule, conte, leia próxima

5

Se qtd > 0: calcule soma/qtd e exiba

⚠️ Cuidado: se o usuário digitar -1 de cara, qtd fica 0. Sempre proteja a divisão com um se qtd > 0.
19 / 19
Resolução · Bônus

Calculadora de média pronta ✅

algoritmo "CalculadoraDeMedia"
var
   soma, nota, media: real
   qtd: inteiro
inicio
   soma <- 0
   qtd  <- 0
   escreval("Nota (-1 p/ encerrar):")
   leia(nota)
   enquanto nota <> -1 faca
      soma <- soma + nota
      qtd  <- qtd + 1
      escreval("Próxima (-1 p/ encerrar):")
      leia(nota)
   fimenquanto
   se qtd > 0 entao
      media <- soma / qtd
      escreval("Total: ", qtd)
      escreval("Média: ", media)
   senao
      escreval("Nenhuma nota inserida.")
   fimse
fimalgoritmo
soma = 0
qtd = 0

nota = float(input("Nota (-1 p/ encerrar): "))

while nota != -1:
    soma = soma + nota
    qtd += 1
    nota = float(input("Próxima (-1 p/ encerrar): "))

if qtd > 0:
    media = soma / qtd
    print("Total:", qtd)
    print(f"Média: {media:.2f}")
else:
    print("Nenhuma nota inserida.")