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.
- Existe uma tarefa.
- Essa tarefa precisa ser repetida.
- 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.
- Por que não é uma boa ideia escrever cem comandos quase iguais em um algoritmo?
- O que caracteriza uma tarefa repetitiva?
- O que é um laço de repetição?
- Qual é a diferença entre condição de continuação e condição de parada?
- O que é um laço infinito?
- Todo algoritmo com repetição precisa terminar? Por quê?
- 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