Estruturas de Repetição

AULA 05 – Estruturas de Repetição: Automatizando Tarefas

Parte 1 – A Necessidade da Repetição

Tema da aula: Por que um algoritmo precisa repetir instruções?

---

Objetivos desta parte

Ao final desta parte você será capaz de:

• compreender por que algoritmos utilizam estruturas de repetição;
• identificar situações em que uma repetição é necessária;
• compreender o conceito de laço de repetição (loop);
• diferenciar uma repetição manual de uma repetição automática;
• entender os conceitos de condição de continuação e condição de parada;
• identificar situações que podem gerar um laço infinito.

---

Retomando a disciplina

Ao longo das quatro primeiras aulas, aprendemos a construir algoritmos capazes de resolver problemas cada vez mais complexos.

Nossa evolução foi a seguinte:

• Aula 01: Como pensar para resolver um problema?
• Aula 02: Como organizar uma solução?
• Aula 03: Como armazenar informações?
• Aula 04: Como tomar decisões?

Até aqui, nossos algoritmos executavam suas instruções apenas uma vez.

Mas muitos problemas exigem que uma mesma ação seja realizada repetidamente.

Surge então uma nova pergunta.

---

A pergunta da aula

Por que repetir manualmente uma mesma instrução se o computador pode fazer isso automaticamente?

Responder essa pergunta nos levará a um dos conceitos mais importantes da programação:

as estruturas de repetição.

---

Situação-Problema

Imagine que um professor deseja escrever os números de 1 até 100 no quadro.

Uma possibilidade seria escrever:

1
2
3
4
5
...
100

Essa tarefa é cansativa, repetitiva e sujeita a erros.

Agora imagine um computador.

Será que faz sentido escrever cem comandos diferentes?

Escreva(1)
Escreva(2)
Escreva(3)
Escreva(4)
...
Escreva(100)

Embora esse algoritmo funcione, ele é extremamente ineficiente.

Um programador experiente faria uma pergunta muito diferente:

Existe uma maneira de ensinar o computador a repetir essa tarefa sozinho?

A resposta é sim.

---

A repetição faz parte da vida

Muito antes dos computadores existirem, as pessoas já realizavam tarefas repetitivas.

Observe alguns exemplos.

Exemplo 1 – Contando alunos

Ao entregar uma prova, o professor repete a mesma ação para cada estudante.

• entrega uma prova;
• chama o próximo aluno;
• entrega outra prova;
• continua até que todos recebam.

---

Exemplo 2 – Enchendo uma caixa

Um funcionário precisa colocar 50 garrafas dentro de uma caixa.

Ele realiza sempre os mesmos movimentos.

• pega uma garrafa;
• coloca na caixa;
• verifica quantas já foram colocadas;
• repete até completar 50.

---

Exemplo 3 – Escovando os dentes

Durante a escovação realizamos diversos movimentos repetitivos.

Os movimentos continuam sendo executados até que a limpeza esteja concluída.

---

Exemplo 4 – Caixa eletrônico

Ao solicitar dinheiro em um caixa eletrônico, o equipamento conta automaticamente as cédulas.

Enquanto ainda houver dinheiro para entregar, ele continua liberando notas.

Quando o valor solicitado é atingido, a operação termina.

---

O que esses exemplos têm em comum?

Em todas essas situações existe um padrão.

1. Existe uma tarefa.
2. Essa tarefa precisa ser repetida.
3. Em algum momento a repetição termina.

Essa ideia pode ser representada da seguinte forma:

Esse é o comportamento básico de qualquer estrutura de repetição.

---

O problema da repetição manual

Considere o seguinte algoritmo.

Escreva(1)
Escreva(2)
Escreva(3)
Escreva(4)
Escreva(5)
Escreva(6)
Escreva(7)
Escreva(8)
Escreva(9)
Escreva(10)

Ele produz exatamente o resultado esperado.

Mas imagine se fosse necessário escrever até:

• 100;
• 1.000;
• 10.000;
• 1.000.000.

O algoritmo se tornaria enorme.

Além disso, qualquer alteração exigiria modificar inúmeras linhas.

---

Um bom algoritmo evita repetições desnecessárias

Uma das características de um bom algoritmo é evitar trabalho repetitivo.

Sempre que identificarmos um conjunto de instruções que será executado várias vezes, devemos procurar uma forma de automatizar essa repetição.

Observe a comparação.

Solução manual

Escreva(1)
Escreva(2)
Escreva(3)
...
Escreva(100)

Solução automatizada

Repita automaticamente a instrução
até chegar ao número 100.

Ainda não sabemos escrever essa solução em Portugol.

Mas já compreendemos sua ideia.

E compreender a ideia sempre vem antes da sintaxe.

---

O conceito de laço de repetição

Chamamos de laço de repetição (ou simplesmente laço) um trecho do algoritmo que pode ser executado várias vezes.

Em inglês, esse mecanismo é conhecido como loop.

O nome “laço” vem justamente da ideia de voltar ao início de um conjunto de instruções sempre que necessário.

Representando de forma simplificada:

Esse ciclo continua até que uma determinada condição indique que a repetição deve terminar.

---

Toda repetição precisa de um objetivo

Um erro comum entre iniciantes é imaginar que repetir é um objetivo em si.

Não é.

Sempre repetimos porque queremos alcançar alguma meta.

Por exemplo:

• contar pessoas;
• somar valores;
• calcular médias;
• processar pedidos;
• validar informações;
• percorrer uma lista de elementos.

A repetição é apenas um meio para resolver um problema.

---

Quando a repetição termina?

Toda estrutura de repetição responde continuamente à seguinte pergunta:

Ainda devo continuar?

Enquanto a resposta for sim, o algoritmo continua repetindo.

Quando a resposta passar a ser não, a repetição termina.

Essa resposta recebe um nome muito importante.

Condição de parada.

Sem uma condição de parada, o algoritmo continuará executando indefinidamente.

---

Condição de continuação × condição de parada

É importante diferenciar dois conceitos.

Condição de continuação

Define quando a repetição deve continuar.

Exemplo:

Enquanto ainda existirem alunos para chamar.

---

Condição de parada

Define quando a repetição deve terminar.

Exemplo:

Quando todos os alunos tiverem recebido a prova.

Observe que ambas descrevem a mesma situação, apenas sob perspectivas diferentes.

---

Situação-Problema

Imagine um algoritmo responsável por contar os passageiros que entram em um ônibus.

Pergunta:

Quando esse algoritmo deve parar de contar?

Algumas respostas possíveis seriam:

• quando o ônibus lotar;
• quando fechar as portas;
• quando iniciar a viagem.

Independentemente da resposta escolhida, uma conclusão é inevitável.

O algoritmo precisa saber exatamente quando interromper a repetição.

---

O perigo dos laços infinitos

Imagine o seguinte algoritmo hipotético.

Enquanto verdadeiro faça
    Escreva("Olá")
FimEnquanto

Pergunta:

Quando esse algoritmo terminará?

A resposta é simples.

Nunca.

Como a condição permanece sempre verdadeira, o algoritmo continuará executando para sempre.

Esse comportamento recebe o nome de laço infinito.

---

Por que laços infinitos são perigosos?

Quando um algoritmo entra em um laço infinito, ele pode:

• consumir continuamente o processador;
• impedir que outras tarefas sejam executadas;
• travar o programa;
• obrigar o usuário a interromper a execução manualmente.

Por isso, um dos cuidados mais importantes ao desenvolver algoritmos é garantir que exista uma condição de parada bem definida.

---

Erros comuns ao construir repetições

1. Esquecer quando a repetição termina

Pergunta:

Como o algoritmo saberá que já fez o suficiente?

Se essa resposta não existir, provavelmente haverá um laço infinito.

---

2. Repetir mais vezes do que o necessário

Imagine contar alunos até 31 quando existem apenas 30.

O algoritmo produzirá um resultado incorreto.

---

3. Parar antes da hora

Também é possível interromper a repetição cedo demais.

Nesse caso, parte do problema ficará sem solução.

---

4. Não atualizar a situação

Em muitas repetições existe uma informação que muda a cada execução.

Por exemplo:

• o número atual da contagem;
• a quantidade de produtos;
• o valor acumulado.

Se essa informação nunca mudar, a condição de parada talvez nunca seja atingida.

Na próxima parte veremos como controlar essa evolução utilizando variáveis de controle, contadores e acumuladores.

---

Resumo desta parte

Nesta primeira parte aprendemos que:

• muitas tarefas exigem repetição;
• repetir manualmente não é eficiente;
• algoritmos utilizam laços para automatizar tarefas repetitivas;
• toda repetição possui um objetivo;
• toda repetição precisa de uma condição de parada;
• laços infinitos ocorrem quando a condição de parada nunca é atingida;
• compreender o raciocínio da repetição é mais importante do que memorizar sua sintaxe.

Na próxima parte transformaremos essas ideias em algoritmos utilizando a estrutura Enquanto…Faça, estudando seu funcionamento, sua sintaxe em Portugol e as primeiras aplicações práticas.

---

Para refletir

Antes de encerrar esta parte, responda mentalmente às perguntas abaixo.

1. Por que não é uma boa ideia escrever cem comandos quase iguais em um algoritmo?
2. O que caracteriza uma tarefa repetitiva?
3. O que é um laço de repetição?
4. Qual é a diferença entre condição de continuação e condição de parada?
5. O que é um laço infinito?
6. Todo algoritmo com repetição precisa terminar? Por quê?
7. Cite três situações do cotidiano em que uma estrutura de repetição poderia ser utilizada.

---

AULA 05 – Estruturas de Repetição: Automatizando Tarefas

Parte 2 – A Estrutura Enquanto…Faça

Tema da aula: Como ensinar o computador a repetir uma tarefa?

---

Objetivos desta parte

Ao final desta parte você será capaz de:

• compreender o funcionamento da estrutura Enquanto…Faça;
• identificar os elementos que compõem uma repetição;
• compreender o papel da variável de controle;
• entender os conceitos de contador e acumulador;
• construir algoritmos simples utilizando a estrutura Enquanto…Faça;
• validar algoritmos por meio do teste de mesa;
• identificar erros comuns na construção de laços de repetição.

---

Retomando a aula

Na primeira parte aprendemos que muitas tarefas exigem repetição.

Também vimos que:

• repetir manualmente não é eficiente;
• toda repetição possui um objetivo;
• toda repetição precisa de uma condição de parada;
• laços infinitos ocorrem quando essa condição nunca é atingida.

Agora surge uma nova pergunta.

A pergunta desta parte

Como ensinar o computador a repetir automaticamente um conjunto de instruções?

A resposta está na primeira estrutura de repetição que estudaremos:

Enquanto…Faça

---

A ideia da estrutura Enquanto…Faça

Imagine que você deseja contar os números de 1 até 5.

Uma pessoa faria algo semelhante a isto:

• escreve 1;
• verifica se terminou;
• escreve 2;
• verifica novamente;
• escreve 3;
• continua até chegar ao 5.

Perceba que existe sempre o mesmo comportamento.

Primeiro ocorre uma verificação.

Depois, caso seja necessário, a tarefa é executada.

Esse processo pode ser representado da seguinte maneira:

Observe que, antes de cada repetição, o algoritmo verifica a condição.

Enquanto ela for verdadeira, o bloco de instruções continuará sendo executado.

Quando a condição se tornar falsa, a repetição termina.

Essa é exatamente a lógica da estrutura Enquanto…Faça.

---

O significado da palavra “Enquanto”

A palavra enquanto representa uma ideia muito simples.

Enquanto uma condição for verdadeira, execute um conjunto de instruções.

Observe alguns exemplos do cotidiano.

Enquanto ainda houver alunos na fila, entregue a próxima prova.

Enquanto ainda existirem garrafas, coloque-as na caixa.

Enquanto ainda houver clientes aguardando, realize o atendimento.

Em todos esses exemplos existe uma condição que controla a repetição.

Quando essa condição deixa de ser verdadeira, a atividade termina.

A programação utiliza exatamente essa mesma lógica.

---

A estrutura Enquanto…Faça em Portugol

Em Portugol, escrevemos essa estrutura da seguinte forma:

Enquanto <condição> Faça
    comandos
FimEnquanto

Observe sua organização.

Existe:

• uma condição;
• um bloco de instruções;
• um comando indicando o término da repetição.

Essa estrutura será utilizada sempre que não soubermos previamente quantas vezes um bloco deverá ser executado, mas soubermos qual condição deve permanecer verdadeira.

---

Primeiro exemplo

Vamos construir um algoritmo que escreva os números de 1 até 5.

Antes de escrever o algoritmo, pense no problema.

Pergunta:

Como o algoritmo saberá qual número deve escrever a seguir?

Ele precisará guardar o número atual.

Para isso utilizaremos uma variável.

Chamaremos essa variável de contador.

---

Algoritmo

Algoritmo "Contagem_1_ate_5"
Var
   numero : Inteiro
Inicio
   numero <- 1
   Enquanto numero <= 5 Faça
      Escreva(numero)
      numero <- numero + 1
   FimEnquanto
FimAlgoritmo

---

Entendendo o algoritmo

Vamos analisar cada etapa.

Primeira etapa

numero <- 1

A variável recebe o primeiro valor da contagem.

---

Segunda etapa

Enquanto numero <= 5 Faça

O algoritmo verifica se ainda deve continuar.

No início:

1 <= 5

Como essa condição é verdadeira, o bloco será executado.

---

Terceira etapa

Escreva(numero)

O algoritmo exibe o valor armazenado.

Neste momento será mostrado:

1

---

Quarta etapa

numero <- numero + 1

Agora ocorre algo muito importante.

O valor da variável muda.

Antes:

numero = 1

Depois:

numero = 2

O algoritmo retorna ao início da repetição.

A condição será verificada novamente.

Esse processo continuará até que:

numero = 6

Nesse momento:

6 <= 5

é falso.

A repetição termina.

---

O papel da variável de controle

Observe novamente o algoritmo.

Existe uma variável que muda a cada repetição.

Ela controla toda a execução do laço.

Essa variável recebe o nome de:

variável de controle.

Sua função é permitir que o algoritmo saiba em que ponto da repetição ele se encontra.

Sem ela, dificilmente a condição de parada seria atingida.

---

O que é um contador?

Em muitos algoritmos precisamos apenas contar quantas vezes algo aconteceu.

Nesse caso utilizamos um contador.

Um contador é uma variável cujo valor aumenta ou diminui de maneira regular durante a repetição.

Exemplos:

• contar alunos;
• contar produtos;
• contar páginas;
• contar votos;
• contar veículos.

Normalmente o contador é atualizado de uma unidade por vez.

contador <- contador + 1

ou

contador <- contador - 1

---

Situação-Problema

Imagine um estacionamento.

Sempre que um veículo entra, o sistema registra sua entrada.

Pergunta:

Como descobrir quantos veículos entraram durante o dia?

A solução é simples.

Criamos um contador.

Cada entrada executa:

contador <- contador + 1

Ao final do expediente, o contador armazenará exatamente a quantidade de veículos registrados.

---

O que é um acumulador?

Nem toda repetição serve apenas para contar.

Às vezes precisamos somar vários valores.

Considere uma padaria.

Durante o dia diversos clientes realizam compras.

Ao final do expediente o sistema precisa calcular o valor total vendido.

Nesse caso não basta contar clientes.

Precisamos acumular valores.

Surge então outra variável muito importante.

O acumulador.

---

Definição

Um acumulador é uma variável utilizada para armazenar um resultado parcial que vai sendo atualizado durante a repetição.

Exemplo:

total <- total + valor

Observe.

A cada repetição:

• o valor anterior é preservado;
• um novo valor é acrescentado;
• o resultado volta para a própria variável.

---

Comparando contador e acumulador

Contador	Acumulador
Conta quantas vezes algo ocorreu.	Soma ou acumula valores.
Geralmente varia de 1 em 1.	Recebe valores diferentes a cada repetição.
Exemplo: quantidade de alunos.	Exemplo: soma das notas.

Ambos são utilizados com frequência nas estruturas de repetição.

Em muitos algoritmos eles aparecem juntos.

---

Exemplo utilizando contador

Problema:

Escrever os números de 1 até 10.

Algoritmo "Contagem"
Var
   contador : Inteiro
Inicio
   contador <- 1
   Enquanto contador <= 10 Faça
      Escreva(contador)
      contador <- contador + 1
   FimEnquanto
FimAlgoritmo

---

Exemplo utilizando acumulador

Problema:

Somar os números de 1 até 5.

Antes de escrever o algoritmo, pense.

Precisaremos de duas variáveis.

Uma controlará a repetição.

A outra armazenará a soma.

Algoritmo "Somatorio"
Var
   numero, soma : Inteiro
Inicio
   numero <- 1
   soma <- 0
   Enquanto numero <= 5 Faça
      soma <- soma + numero
      numero <- numero + 1
   FimEnquanto
   Escreva("Soma = ", soma)
FimAlgoritmo

---

Teste de Mesa

Vamos acompanhar a execução do algoritmo.

Repetição	Número	Soma antes	Soma depois
1	1	0	1
2	2	1	3
3	3	3	6
4	4	6	10
5	5	10	15

Ao final:

Soma = 15

Observe que o acumulador guarda o resultado parcial durante toda a execução.

---

Erros comuns ao utilizar o Enquanto

1. Esquecer de atualizar a variável de controle

Enquanto numero <= 10 Faça
   Escreva(numero)
FimEnquanto

Pergunta:

Quando esse algoritmo terminará?

Resposta:

Nunca.

Como numero nunca muda, a condição permanecerá verdadeira.

O algoritmo entrará em um laço infinito.

---

2. Inicializar a variável incorretamente

Observe.

numero <- 20
Enquanto numero <= 10 Faça

Pergunta:

O que acontecerá?

Nada será executado.

Logo na primeira verificação:

20 <= 10

é falso.

O algoritmo encerrará imediatamente.

---

3. Atualizar a variável no sentido errado

Observe.

numero <- numero - 1

quando a condição é

numero <= 10

Nesse caso, a variável se afasta da condição de parada.

O laço poderá nunca terminar.

---

Boas práticas

Ao construir um algoritmo com repetição, procure responder às seguintes perguntas:

• Qual variável controla a repetição?
• Qual é o valor inicial dessa variável?
• Como ela será atualizada?
• Em que momento a repetição deverá terminar?

Responder a essas perguntas antes de escrever o algoritmo reduz significativamente a ocorrência de erros.

---

Resumo desta parte

Nesta segunda parte aprendemos que:

• a estrutura Enquanto…Faça permite repetir automaticamente um conjunto de instruções;
• a condição é verificada antes de cada repetição;
• uma variável de controle acompanha a evolução do laço;
• contadores registram quantidades;
• acumuladores armazenam resultados parciais;
• atualizar corretamente a variável de controle é essencial para evitar laços infinitos.

Na próxima parte aplicaremos esses conceitos na resolução de problemas mais elaborados, construindo algoritmos completos com estruturas de repetição e desenvolvendo estratégias para validar suas soluções por meio do teste de mesa.

---

AULA 05 – Estruturas de Repetição: Automatizando Tarefas

Parte 3 – Resolvendo Problemas com Estruturas de Repetição

Tema da aula: Aplicando a estrutura Enquanto…Faça na resolução de problemas.

---

Objetivos desta parte

Ao final desta parte você será capaz de:

• aplicar a estrutura Enquanto…Faça na resolução de problemas;
• utilizar contadores e acumuladores em um mesmo algoritmo;
• desenvolver algoritmos que realizem contagens e cálculos repetitivos;
• construir algoritmos que leiam uma quantidade indefinida de valores;
• validar algoritmos por meio do teste de mesa;
• analisar e corrigir erros lógicos em estruturas de repetição.

---

Retomando a aula

Na parte anterior aprendemos que a estrutura Enquanto…Faça permite repetir automaticamente um conjunto de instruções.

Também vimos que toda repetição necessita de:

• uma condição de continuação;
• uma variável de controle;
• uma atualização dessa variável;
• uma condição de parada.

Agora surge uma nova pergunta.

A pergunta desta parte

Como utilizar uma estrutura de repetição para resolver problemas reais?

A resposta está na construção de algoritmos cada vez mais completos.

Até este momento, utilizamos repetições apenas para exibir números.

Agora utilizaremos as repetições para processar informações.

---

Situação-Problema

Imagine uma escola que deseja calcular a soma das notas obtidas por cinco estudantes em uma atividade.

Seria possível escrever um algoritmo como este:

Leia(nota1)
Leia(nota2)
Leia(nota3)
Leia(nota4)
Leia(nota5)

soma <- nota1 + nota2 + nota3 + nota4 + nota5

Esse algoritmo funciona.

Mas imagine se a turma tivesse:

• 30 alunos;
• 200 alunos;
• 800 alunos.

Seria necessário criar centenas de variáveis e centenas de comandos.

Essa solução não é prática.

Uma estrutura de repetição resolve esse problema de maneira elegante.

---

Problema 1 – Somando os números de 1 até 10

Vamos construir um algoritmo que calcule:

1 + 2 + 3 + 4 + ... + 10

Observe que precisaremos de duas variáveis.

A primeira controlará a repetição.

A segunda armazenará a soma.

---

Algoritmo

Algoritmo "Somatorio_1_ate_10"
Var
   numero, soma : Inteiro
Inicio
   numero <- 1
   soma <- 0
   Enquanto numero <= 10 Faça
      soma <- soma + numero
      numero <- numero + 1
   FimEnquanto
   Escreva("Soma = ", soma)
FimAlgoritmo

---

Como o algoritmo funciona?

Observe a sequência de execução.

Inicialmente:

numero = 1
soma = 0

Primeira repetição:

soma = 0 + 1

Resultado:

soma = 1

Segunda repetição:

soma = 1 + 2

Resultado:

soma = 3

Esse processo continua até que:

numero = 11

Nesse momento, a condição

numero <= 10

torna-se falsa.

O algoritmo termina.

---

Teste de Mesa

Repetição	Número	Soma antes	Soma depois
1	1	0	1
2	2	1	3
3	3	3	6
4	4	6	10
5	5	10	15
6	6	15	21
7	7	21	28
8	8	28	36
9	9	36	45
10	10	45	55

Resultado final:

Soma = 55

---

Observação

Perceba que o algoritmo realiza duas tarefas simultaneamente.

O contador controla a repetição.

O acumulador registra o resultado parcial.

Essa combinação aparece em inúmeros algoritmos.

---

Problema 2 – Calculando a média de uma turma

Uma escola deseja calcular a média das notas de cinco estudantes.

Pergunta:

Quais informações precisamos armazenar?

Resposta:

• a nota atual;
• a soma das notas;
• a quantidade de notas lidas.

---

Algoritmo

Algoritmo "Media_Turma"
Var
   nota, soma : Real
   contador : Inteiro
   media : Real
Inicio
   contador <- 1
   soma <- 0
   Enquanto contador <= 5 Faça
      Escreva("Digite a nota: ")
      Leia(nota)
      soma <- soma + nota
      contador <- contador + 1
   FimEnquanto
   media <- soma / 5
   Escreva("Média = ", media)
FimAlgoritmo

---

Analisando a solução

Observe a sequência.

Durante a repetição:

• uma nota é lida;
• a nota é adicionada ao acumulador;
• o contador é atualizado.

Somente após o término da repetição é calculada a média.

Esse detalhe é importante.

Não faz sentido calcular a média antes de possuir todas as notas.

---

Problema 3 – Contando números pares

Agora desejamos descobrir quantos números pares existem entre 1 e 20.

---

Algoritmo

Algoritmo "Contar_Pares"
Var
   numero, quantidade : Inteiro
Inicio
   numero <- 1
   quantidade <- 0
   Enquanto numero <= 20 Faça
      Se numero MOD 2 = 0 Então
         quantidade <- quantidade + 1
      FimSe
      numero <- numero + 1
   FimEnquanto
   Escreva("Quantidade = ", quantidade)
FimAlgoritmo

---

Integração de estruturas

Observe algo novo.

Dentro da repetição existe uma estrutura de decisão.

Isso significa que estruturas de controle podem ser combinadas.

Temos:

Enquanto
    Se
        instruções
    FimSe
FimEnquanto

Essa combinação é extremamente comum.

Na prática, algoritmos reais utilizam estruturas sequenciais, decisões e repetições ao mesmo tempo.

---

Problema 4 – Encontrando o maior valor

Uma loja deseja descobrir qual foi a maior venda registrada entre cinco vendedores.

Pergunta:

Como descobrir o maior valor sem conhecer previamente os números?

A estratégia consiste em comparar cada novo valor com o maior encontrado até aquele momento.

---

Algoritmo

Algoritmo "Maior_Valor"
Var
   valor, maior : Real
   contador : Inteiro
Inicio
   contador <- 1
   Enquanto contador <= 5 Faça
      Leia(valor)
      Se contador = 1 Então
         maior <- valor
      Senão
         Se valor > maior Então
            maior <- valor
         FimSe
      FimSe
      contador <- contador + 1
   FimEnquanto
   Escreva("Maior valor = ", maior)
FimAlgoritmo

---

Por que o primeiro valor recebe tratamento especial?

Observe.

Antes da primeira leitura, a variável:

maior

não possui um valor válido.

Por isso, o primeiro número lido torna-se, temporariamente, o maior.

A partir da segunda leitura, começam as comparações.

Essa técnica será utilizada diversas vezes ao longo da disciplina.

---

Estudo de Caso

Uma biblioteca deseja registrar o número de livros emprestados durante cinco dias.

Os dados são:

Dia	Livros
Segunda	18
Terça	24
Quarta	20
Quinta	17
Sexta	26

Deseja-se calcular:

• o total de empréstimos;
• a média diária.

Pergunta:

Quais variáveis seriam necessárias?

Resposta:

• contador;
• livros;
• total;
• média.

Observe que o algoritmo segue exatamente o mesmo padrão estudado anteriormente.

Mudam apenas os dados processados.

A lógica permanece praticamente a mesma.

---

Padrão Geral dos Algoritmos com Repetição

Grande parte dos algoritmos construídos com Enquanto…Faça segue a estrutura abaixo.

Inicialização
↓
Enquanto condição Faça
      Ler dados
      Processar
      Atualizar variáveis
FimEnquanto
↓
Apresentar resultados

Reconhecer esse padrão facilita a construção de novos algoritmos.

---

Erros frequentes

Calcular o resultado dentro da repetição sem necessidade

Observe.

media <- soma / 5

Esse cálculo deve ser realizado após o término da repetição.

Executá-lo dentro do laço apenas aumenta o número de operações realizadas.

---

Esquecer de inicializar o acumulador

Observe.

soma <- 0

Sem essa inicialização, a variável poderá conter um valor indefinido, comprometendo o resultado final.

---

Atualizar a variável errada

Observe.

soma <- soma + 1

quando o correto seria:

contador <- contador + 1

Esse erro pode impedir o encerramento da repetição ou produzir resultados incorretos.

---

Boas práticas

Sempre que construir um algoritmo com repetição, procure identificar:

• Qual variável controla o laço?
• Qual variável acumula resultados?
• Quais valores serão lidos?
• Em que momento os cálculos devem ser realizados?
• Quando o algoritmo deve terminar?

Responder a essas perguntas antes de iniciar a implementação reduz significativamente a ocorrência de erros.

---

Exercícios Propostos

Exercício 1

Construa um algoritmo que escreva os números de 1 até 50.

---

Exercício 2

Construa um algoritmo que escreva apenas os números pares entre 2 e 100.

---

Exercício 3

Leia dez números inteiros e calcule a soma de todos eles.

---

Exercício 4

Leia cinco notas e determine:

• a soma das notas;
• a média da turma.

---

Exercício 5

Leia dez números e informe qual deles possui o maior valor.

---

Resumo desta parte

Nesta terceira parte aprendemos que:

• estruturas de repetição permitem resolver problemas de forma eficiente;
• contadores e acumuladores normalmente trabalham em conjunto;
• decisões podem ser utilizadas dentro de repetições;
• muitos algoritmos seguem um mesmo padrão de construção;
• o teste de mesa continua sendo uma das melhores ferramentas para validar algoritmos antes da implementação.

Na próxima parte consolidaremos o estudo das estruturas de repetição por meio de estudos de caso, exercícios graduados, desafios e um panorama geral dos conceitos desenvolvidos na Aula 05.

---

AULA 05 – Estruturas de Repetição: Automatizando Tarefas

Parte 4 – Consolidando as Estruturas de Repetição

Tema da aula: Aplicando estruturas de repetição na resolução de problemas.

---

Objetivos desta parte

Ao final desta parte você será capaz de:

• aplicar corretamente a estrutura Enquanto…Faça em diferentes situações;
• analisar algoritmos utilizando teste de mesa;
• identificar erros comuns em estruturas de repetição;
• escolher estratégias adequadas para resolver problemas repetitivos;
• construir algoritmos mais completos utilizando contadores, acumuladores e decisões;
• compreender como as estruturas de repetição serão utilizadas nas próximas aulas da disciplina.

---

Retomando a aula

Ao longo desta aula aprendemos que:

• muitas tarefas exigem repetição;
• a estrutura Enquanto…Faça automatiza tarefas repetitivas;
• toda repetição possui uma condição de continuação;
• toda repetição necessita de uma condição de parada;
• variáveis de controle impedem laços infinitos;
• contadores e acumuladores permitem resolver diversos problemas computacionais.

Agora chegou o momento de integrar todos esses conhecimentos.

---

Situação-Problema

Imagine um supermercado.

Durante o expediente, cada cliente realiza uma compra de valor diferente.

Ao final do dia, o gerente deseja responder às seguintes perguntas:

• Quantos clientes foram atendidos?
• Qual foi o valor total vendido?
• Qual foi a maior compra realizada?

Observe que nenhuma dessas informações é conhecida antecipadamente.

Elas serão descobertas à medida que cada atendimento ocorrer.

Essa é uma característica muito comum em sistemas computacionais.

---

Estudo de Caso 1 – Totalizando Vendas

Suponha que um caixa registre as compras de cinco clientes.

O algoritmo deverá:

• ler o valor de cada compra;
• calcular o total arrecadado;
• apresentar o resultado final.

Algoritmo

Algoritmo "Total_Vendas"
Var
   contador : Inteiro
   compra, total : Real
Inicio
   contador <- 1
   total <- 0
   Enquanto contador <= 5 Faça
      Escreva("Valor da compra: ")
      Leia(compra)
      total <- total + compra
      contador <- contador + 1
   FimEnquanto
   Escreva("Total arrecadado = R$ ", total)
FimAlgoritmo

---

Analisando o algoritmo

Observe que três tarefas acontecem durante cada repetição.

Primeiro:

Leia(compra)

Depois:

total <- total + compra

Por fim:

contador <- contador + 1

Esse padrão será utilizado em diversos algoritmos.

Sempre que houver necessidade de processar vários dados semelhantes, a estrutura será praticamente a mesma.

---

Estudo de Caso 2 – Contando Valores Positivos

Deseja-se descobrir quantos números positivos existem entre dez valores informados pelo usuário.

Pergunta:

É necessário armazenar todos os números?

A resposta é não.

Precisamos apenas:

• ler um número;
• verificar se ele é positivo;
• aumentar um contador quando necessário.

---

Algoritmo

Algoritmo "Contar_Positivos"
Var
   numero : Real
   contador, positivos : Inteiro
Inicio
   contador <- 1
   positivos <- 0
   Enquanto contador <= 10 Faça
      Leia(numero)
      Se numero > 0 Então
         positivos <- positivos + 1
      FimSe
      contador <- contador + 1
   FimEnquanto
   Escreva("Quantidade de positivos = ", positivos)
FimAlgoritmo

---

Integrando repetição e decisão

Observe que agora duas estruturas trabalham juntas.

Enquanto
     Se
          instruções
     FimSe
FimEnquanto

Essa combinação representa uma grande evolução em relação às aulas anteriores.

Até a Aula 04, utilizávamos apenas decisões.

Agora, essas decisões podem ser executadas repetidamente.

---

Estudo de Caso 3 – Somando Apenas os Números Pares

Deseja-se calcular a soma apenas dos números pares entre 1 e 20.

Pergunta:

Todos os números serão somados?

Não.

Primeiro será necessário verificar se o número é par.

Somente depois ele será acumulado.

---

Algoritmo

Algoritmo "Somar_Pares"
Var
   numero, soma : Inteiro
Inicio
   numero <- 1
   soma <- 0
   Enquanto numero <= 20 Faça
      Se numero MOD 2 = 0 Então
         soma <- soma + numero
      FimSe
      numero <- numero + 1
   FimEnquanto
   Escreva("Soma = ", soma)
FimAlgoritmo

---

Teste de Mesa

Acompanhe a execução.

Número	É par?	Soma
1	Não	0
2	Sim	2
3	Não	2
4	Sim	6
5	Não	6
6	Sim	12
…	…	…
20	Sim	110

Resultado final:

Soma = 110

---

Estudo de Caso 4 – Encontrando o Menor Valor

Uma empresa deseja descobrir o menor preço informado por cinco fornecedores.

A lógica é semelhante ao problema do maior valor estudado anteriormente.

A diferença é que agora a comparação será inversa.

---

Algoritmo

Algoritmo "Menor_Valor"
Var
   preco, menor : Real
   contador : Inteiro
Inicio
   contador <- 1
   Enquanto contador <= 5 Faça
      Leia(preco)
      Se contador = 1 Então
         menor <- preco
      Senão
         Se preco < menor Então
            menor <- preco
         FimSe
      FimSe
      contador <- contador + 1
   FimEnquanto
   Escreva("Menor preço = ", menor)
FimAlgoritmo

---

Padrão Geral dos Algoritmos com Repetição

Após estudar diversos exemplos, podemos identificar um padrão comum.

Inicializar variáveis
↓
Enquanto condição Faça
      Ler dados
      Tomar decisões (quando necessário)
      Atualizar contadores
      Atualizar acumuladores
FimEnquanto
↓
Apresentar resultados

Reconhecer esse padrão facilita a resolução de novos problemas.

---

Erros mais frequentes

1. Esquecer de atualizar a variável de controle

Exemplo:

Enquanto contador <= 10 Faça
   Escreva(contador)
FimEnquanto

Como o contador nunca é alterado, a condição permanecerá verdadeira indefinidamente.

O algoritmo entrará em um laço infinito.

---

2. Inicializar incorretamente um acumulador

Observe:

soma <- 10

Quando o objetivo é somar valores, o acumulador normalmente deve iniciar com:

soma <- 0

Caso contrário, o resultado será incorreto.

---

3. Atualizar o contador no local errado

Observe:

contador <- contador + 1

Essa atualização deve ocorrer dentro da repetição e em um ponto que garanta a execução correta de todas as instruções do laço.

---

4. Utilizar a variável errada

Exemplo:

soma <- soma + 1

quando o correto seria:

contador <- contador + 1

Esse tipo de erro é bastante comum entre iniciantes.

---

Estratégia para resolver problemas com repetição

Sempre que encontrar um problema envolvendo repetição, procure responder às seguintes perguntas.

1. O que deve ser repetido?

Exemplo:

• ler notas;
• calcular vendas;
• contar pessoas.

---

2. Quando a repetição deve terminar?

Exemplos:

• após dez repetições;
• quando o contador atingir determinado valor;
• quando uma condição deixar de ser verdadeira.

---

3. Quais variáveis serão necessárias?

Pergunte:

• preciso contar?
• preciso somar?
• preciso comparar?
• preciso armazenar o maior ou o menor valor?

---

4. O que será apresentado ao final?

Somente após responder essas perguntas vale a pena iniciar a construção do algoritmo.

---

Exercícios Resolvidos

Exercício Resolvido 1

Construa um algoritmo que escreva os números de 10 até 20.

Solução

numero <- 10
Enquanto numero <= 20 Faça
   Escreva(numero)
   numero <- numero + 1
FimEnquanto

---

Exercício Resolvido 2

Construa um algoritmo que conte quantos números múltiplos de cinco existem entre 1 e 50.

Ideia:

• percorrer todos os números;
• verificar o resto da divisão;
• aumentar um contador quando necessário.

---

Exercícios Propostos

Exercício 1

Escreva os números de 50 até 100.

---

Exercício 2

Escreva apenas os números ímpares entre 1 e 99.

---

Exercício 3

Leia dez números inteiros e calcule:

• a soma;
• a média.

---

Exercício 4

Leia dez números e informe:

• o maior valor;
• o menor valor.

---

Exercício 5

Leia as idades de vinte pessoas e informe:

• quantas são maiores de idade;
• quantas são menores de idade.

---

Exercício 6

Leia cinco salários e calcule:

• o total da folha de pagamento;
• o salário médio.

---

Desafio

Uma academia deseja registrar a frequência semanal de sete alunos.

Para cada aluno será informado o número de dias em que compareceu durante a semana.

Ao final, o algoritmo deverá informar:

• o total de presenças;
• a média de frequência;
• quantos alunos compareceram cinco dias ou mais.

Planeje o algoritmo antes de escrevê-lo.

Identifique:

• entradas;
• processamento;
• saídas;
• variáveis necessárias.

---

Resumo da Aula 05

Ao longo desta aula aprendemos que:

• estruturas de repetição automatizam tarefas repetitivas;
• a estrutura Enquanto…Faça executa um bloco de instruções enquanto uma condição for verdadeira;
• contadores controlam o número de repetições;
• acumuladores armazenam resultados parciais;
• estruturas de decisão podem ser utilizadas dentro de estruturas de repetição;
• o teste de mesa continua sendo uma ferramenta essencial para validar algoritmos;
• praticamente todos os algoritmos com repetição seguem um mesmo padrão de construção.

---

Preparando a próxima aula

Até este momento, todas as repetições estudadas dependiam de uma condição controlada manualmente pelo algoritmo.

Na próxima aula estudaremos outra estrutura de repetição muito utilizada em programação, indicada para situações em que a quantidade de repetições já é conhecida antecipadamente.

Conheceremos a estrutura Para…Faça, compararemos seu funcionamento com a estrutura Enquanto…Faça e aprenderemos quando utilizar cada uma delas.

---

Encerramento da Aula 05

Com esta aula, concluímos o estudo das estruturas fundamentais da programação sequencial:

• sequência;
• decisão;
• repetição.

Esses três pilares formam a base da programação estruturada e serão utilizados em praticamente todos os algoritmos desenvolvidos ao longo da disciplina.

---

Fim da aula 05