Algoritmos I - Parte 3

Prévia do material em texto

UNIVERSIDADE COMUNITÁRIA DA REGIÃO DE CHAPECÓ 
ACEA 
CURSO DE CIÊNCIA DA COMPUTAÇÃO 
 
 
 
 
 
 
 
Algoritmos e Estrutura de Dados I 
 
 
 
Apostila da Disciplina – Parte 3 
Estruturas de Repetição 
 
 
 
 
 
 
 
 
Prof. José Carlos Toniazzo 
 
 
 
 
 
 
 
 
 
Chapecó, 2011 
Estruturas de Repetição 
 
Uma repetição, também chamada de laço ou loop, é uma estrutura que permite executar um 
trecho de um algoritmo várias vezes seguidas. Veremos dois tipos de estruturas básicas, a 
repetição com teste no início e a repetição com teste no final, e fecharemos o estudo de 
repetições com o caso complementar da repetição com variável de controle. 
 
1 – Comandos repita e enquanto (para repetir um número indefinido de vezes) 
 
Tanto o comando repita quanto o comando enquanto permitem repetir um ou mais comandos 
no corpo de um algoritmo. A sintaxe dos comandos é: 
 
repita 
<comando1>; 
<comando2>; 
. 
. 
. 
<comandoN>; 
até <expressão>; 
 
 
 
enquanto <expressão> faça 
<comando>; 
 
 
2 – Comando para...faça (para repetir um número definido de vezes) 
 
 
Além destes temos o para...faça, que é uma estrutura de repetição utilizada quando sabemos 
quantas vezes queremos repetir um laço. 
 
 
Para... Faça 
<comando>; 
. 
. 
. 
 
 
 
 
Para todas as condições há um teste feito através de uma expressão lógica, que indica se o 
laço deve continuar ou parar. 
 
Para o primeiro caso, quando o computador encontra a palavra repita, ele saberá que todos 
os comandos seguintes, até encontrar a palavra até, estarão dentro de um laço e serão 
executados. Após a palavra até deve existir uma expressão lógica; sendo falsa, o computador 
voltará para o primeiro comando após a palavra repita, e todo o trecho será novamente 
executado. A repetição continua até que o resultado da expressão lógica seja verdadeiro, 
indicando que o laço acabou e que o computador deve seguir a seqüência do algoritmo. 
 
Chamamos esta estrutura de repetição com teste no final, pois a decisão entre repetir ou 
parar o laço é feita ao final do comando; conclui-se, portanto, que sempre haverá pelo menos 
uma execução do trecho delimitado. O teste é executado após os comandos serem 
executados pelo menos uma vez. Isso garante que aquele trecho de código será executado 
PELO MENOS em uma iteração. 
 
Para o segundo caso, a palavra enquanto indica que o comando seguinte será executado, 
desde que o resultado da expressão lógica seja verdadeiro. Em nosso português estruturado, 
nada impede que também possamos pedir para executar um comando composto (um bloco, 
delimitado por chaves {}). 
 
Ao encontrar o final do comando (ou do bloco), o computador volta para a 1ª linha do laço e 
verifica se a expressão lógica ainda é verdadeira; se sim, fará uma nova execução do trecho, 
se não, pára a execução do laço e continua no próximo comando após o trecho repetido. 
 
Chamados esta estrutura de repetição com teste no início, pois a decisão entre repetir ou 
parar o laço é feita no começo do comando; se o teste for falso logo na 1ª vez, o trecho 
delimitado não será executado. 
 
O terceiro quadro apresenta o Para... faça, que foi estudado e deve ser utilizado em situações 
onde sabemos quantas vezes vamos executar um laço. 
 
 
Comparando: 
 
- o para...faça é uma estrutura de repetição que normalmente está associada a um índice, e 
através dele executados um número DETERMINADO de vezes, ou seja, sabemos quantas 
vezes queremos repetir o laço; 
Ex; Ler e mostrar na tela 10 números. 
 
- enquanto... faça, ao contrário do para... faça, é utilizado quando NÃO SABEMOS QUANTAS 
VEZES O LAÇO IRÁ EXECUTAR. Nas situações onde o laço pode executar de 0 até N vezes, 
ou seja, um número determinado de vezes, devemos fazer o laço utilizando o enquanto...faça. 
Ex: Ler números até que um valor negativo seja informado 
 
- repita...até (alguns autores denominam faça..enquanto). É similar ao enquanto...faça, com a 
diferença de que o laço deve executar PELO MENOS UMA VEZ, pois o teste é feito no final. 
Sendo assim, o laço irá repetir de 1 até N vezes. Usado em situações onde pelo menos uma 
vez os comandos devem ser executados. 
Ex: Testar o Login de um Sistema (pelo menos uma vez deve pedir para digitar usuário e 
senha) 
 
 
OBS: É de grande importância que o aluno diferencie cada um dos laços de repetição e 
escolha o laço certo para utilizar no desenvolvimento de um algoritmo correto e 
eficiente 
 
 
 
 
 
 
 
Exemplo 1: 
 
Fazer um algoritmo para ler diversos números informados pelo usuário, e após cada leitura 
exibir se o número é par ou ímpar. Considere que ao fornecer um valor negativo o usuário 
deseja encerrar a entrada de dados. 
 
Solução: 
 
Se não existissem estruturas de repetição, nossa primeira versão do algoritmo poderia ser 
algo do tipo: 
 
// Algoritmo incompleto e errado 
Variáveis 
NUM1, NUM2, NUM3, ... ? : inteiro; 
Início 
ler NUM1; 
se (NUM1 % 2) = 0 então 
escrever ‘ O número é par’; 
senão 
escrever ‘O número é impar’; 
ler NUM2; 
se (NUM2 % 2) = 0 então 
escrever ‘ O número é par’; 
senão 
escrever ‘O número é impar’; 
ler NUM3; 
se (NUM3 % 2) = 0 então 
escrever ‘ O número é par’; 
senão 
escrever ‘O número é impar’; 
??? 
Fim 
 
Para descobrir se um número é par, testamos se o resto da sua divisão por 2 é zero; sendo 
verdadeiro, o número é par e sendo falso o número é ímpar. O grande problema que impede 
terminar o algoritmo é que não sabemos de antemão quantos dados serão fornecidos; 
além de inviabilizar a montagem da listagem dos comandos, também não saberíamos quantas 
variáveis seriam criadas. 
 
Vamos então incluir o trecho que naturalmente está sendo repetido dentro de um comando 
de repetição repita, declarando apenas uma única variável: 
 
//Algoritmo quase correto 
Variáveis 
NUM: inteiro; 
Inicio 
repita 
{ 
ler NUM; 
 
se (NUM % 2) = 0 então 
escrever ‘ O número é par’; 
senão 
escrever ‘O número é impar’; 
 
até NUM < 0; 
} 
Fim. 
 
Nosso laço agora repete dois comandos: uma leitura e um comando de decisão (lembre-se de 
que, apesar de estar escrito em mais de uma linha, o se-então-senão é um comando só). 
Suponha que na 1ª leitura o usuário forneça o valor 7. Seguindo a seqüência, o computador 
terá um teste falso e escreverá a mensagem de que o número é ímpar. Ao encontrar a palavra 
até o teste do laço será falso (pois 7 não é menor que 0), e o computador volta novamente 
para o comando de leitura. 
 
Com este laço, o usuário poderá ficar indefinidamente fornecendo números para a máquina, 
recebendo como resposta a informação de que ele é par ou ímpar. Mas se ele decidir parar a 
repetição e entrar com um número negativo, digamos -1, ainda assim o computador tentará 
exibir uma mensagem para este último valor, pois estará seguindo a sequência do laço. Veja 
um exemplo: 
 
8 -> o número é par 
11 -> o número é ímpar 
21 -> o número é ímpar 
8 -> o número é par 
-1 -> o número é ímpar (PROBLEMA!) 
 
Uma maneira de contornar o problema seria modificar o teste dentro do laço: 
 
// Algoritmo correto mas deselegante 
 
Variáveis 
NUM: inteiro; 
Inicio 
repita 
 ler NUM; 
 se (NUM >= 0) e (NUM % 2) = 0 então 
escrever ‘ O número é par’; 
senão 
escrever ‘O número é impar’; 
até NUM < 0; 
Fim. 
 
O algoritmo agora executa uma solução correta para o problema. Esta solução, contudo, é um 
pouco deselegante, pois sabe-se que o teste NUM>=0 sempre será verdadeiro, exceto no 
último caso. 
 
Vejamos uma tentativa de solução com o comando enquanto. 
 
// Algoritmo incompleto 
Variáveis 
NUM: inteiro; 
Inicio 
enquanto NUM >= 0 faça 
{ 
 ler NUM; 
 se (NUM>= 0) e (NUM % 2) = 0 então 
escrever ‘ O número é par’; 
senão 
escrever ‘O número é impar’; 
} 
 
Fim. 
 
O bloco de comandos foi necessário porque queremos executar mais de um comando dentro 
do enquanto (no repita não há necessidade de bloco, pois sua sintaxe já delimita um início e 
um final para a repetição). 
 
Este algoritmo apresenta um problema, pois como agora o teste é feito no início do laço, já 
deveria haver um valor na variável NUM na 1ª vez (e não há, tornando a execução 
imprevisível). É preferível deslocar a leitura para antes do começo do laço, fazendo a variável 
NUM ter um valor logo no início da repetição: 
 
// Algoritmo incompleto 
Variáveis 
NUM: inteiro; 
Inicio 
ler NUM; 
enquanto NUM >= 0 faça 
{ 
se (NUM >= 0) e (NUM % 2) = 0 então 
escrever ‘ O número é par’; 
senão 
escrever ‘O número é impar’; 
} 
Fim. 
 
Por outro lado, deixando o algoritmo assim podemos cair em um laço infinito. Se na 1ª vez o 
usuário fornecer um valor válido, como 8, o algoritmo entrará no laço e imprimirá a mensagem 
de que o número é par. Como não há outro comando após o comando de decisão, o 
computador volta e testa novamente se NUM>=0. O usuário não teve chance de fornecer 
outro número; logo, o valor continuará sendo 8 e o algoritmo ficará indefinidamente 
imprimindo: 
 
O número é par 
O número é par 
O número é par 
O número é par 
O número é par 
... 
Finalmente, vamos então incluir outro comando de leitura dentro do laço, e complementar 
mensagens de auxílio ao usuário: 
 
// Algoritmo completo 
Variáveis 
NUM: inteiro; 
Inicio 
escrever ‘Entre com um número: ’; 
ler NUM; 
enquanto NUM >= 0 faça 
{ 
se (NUM % 2) = 0 então 
escrever ‘ O número é par’; 
senão 
escrever ‘O número é impar’; 
 
escrever ‘Entre com um número: ‘; 
ler NUM; 
 } 
escrever ‘Fim do algoritmo’; 
Fim. 
 
Independente de qual estrutura de repetição utilzar, sempre devemos lembrar das 
características de cada uma e fazer a escolha que torne viável e correta a resolução dos 
problemas utilizando o conceito de algoritmos. 
 
Algumas dicas: 
 
- Escolher sempre a estrutura de repetição mais adequada; 
 
- Verificar a possibilidade de trabalhar com mais de uma estrutura no mesmo 
algoritmo, dependendo do problema a ser resolvido; 
 
- Entender que toda a estrutura de repetição está vinculada a um teste condicional, o 
que a repetição termina quando o teste condicional determinar; 
 
- Em hipótese alguma fazer um algoritmo com laço de repetição infinito, pois isto torna 
o algoritmo incorreto. 
 
 
Conclusão 
 
No estudo da informática o algoritmo e como o alicerce de uma casa, sem ele não se 
pode construir as paredes e o telhado, ou seja, sem o algoritmo não se pode criar um estudo 
sistematizado em nenhum campo da informática. 
 
No mundo atual praticamente todas as tarefas podem ser automatizadas, e para isso 
fazemos o uso de computadores. E os computadores precisam de receberem ordens para 
funcionarem, daí a necessidade de algoritmos. 
 
Para aprendermos a criar algoritmos não basta estudar ou copiar algoritmos, para se 
aprender como manipular situações e codificá-las em forma de algoritmo precisamos de 
escrever e criar algoritmos, pegar exercícios, e praticar. 
 
Exercícios 
 
1 - Construir um algoritmo que calcule a média aritmética de vários valores inteiros positivos, 
lidos externamente. O final da leitura acontecerá quando for lido um valor negativo. 
 
2. Escreva um algoritmo que leia 50 valores e encontre o maior e o menor deles. Mostre o 
resultado. 
 
3- Faça um algoritmo que leia vários números inteiros e calcule o somatório dos números 
negativos. O fim da leitura será indicado pelo número 0. 
4. Escrever um algoritmo que leia um número não determinado de valores e calcule a média 
aritmética dos valores lidos, a quantidade de valores positivos, a quantidade de valores 
negativos e o percentual de valores negativos e positivos. Mostre os resultados. 
5. Escrever um algoritmo que leia uma quantidade desconhecida de números e conte quantos 
deles estão nos seguintes intervalos: [0.25], [26,50], [51,75] e [76,100]. A entrada de dados 
deve terminar quando for lido um número negativo.