Baixe comando de repetiçao e outras Notas de estudo em PDF para Análise de Sistemas de Engenharia, somente na Docsity!
Capítulo 4
Comandos de Repetição
No mundo real, é comum a repetição de procedimentos para se realizar tarefas. Esses
procedimentos não são repetidos eternamente, mas se encerram quando o objetivo é
atingido. Por exemplo, quando uma pessoa aperta um parafuso, ela gira a chave de fenda
uma vez, duas vezes etc. até que o parafuso esteja apertado o suficiente. Durante esse
processo, é verificado, a cada volta, se o parafuso já está bem firme.
Da mesma forma, podemos estruturar várias atividades diárias como repetitivas. Durante
a chamada feita por um professor, por exemplo, ele chama os nomes enquanto não
terminar a lista. Outras repetições podem ser quantificadas com antecedência. O aluno
de castigo que precisa escrever 100 vezes no quadro negro: “Não vou fazer bagunça
nunca mais”, executa a mesma instrução 100 vezes.
Todas as repetições têm uma característica comum: o fato de haver uma verificação de
condição que pode ser representada por um valor lógico, para determinar se a repetição
prossegue ou não. Essa é a base para a implementação dos comandos de repetição em
algoritmos. Em vez de fazermos um trabalho braçal, escrevendo a mesma instrução várias
vezes, poderemos utilizar uma estrutura que indique que tal instrução será executada
quantas vezes for necessária.
4.1 Comando enquanto
Antes de vermos a sintaxe em nosso pseudocódigo, vejamos um exemplo do mundo
real: o problema do elevador.
Um elevador residencial tem um comportamento que pode ser descrito de forma algo-
rítmica. Vejamos o seu funcionamento:
- Na subida : sobe cada andar, verificando se está em um andar selecionado dentro
do elevador. Isso é feito até chegar ao andar mais alto selecionado dentro ou fora do
elevador.
Capítulo 4 • Comandos de Repetição 61
enquanto não chegar ao andar mais alto selecionado interna/externamente faça início suba um andar, se o andar foi selecionado internamente então início pare, abra as portas, feche as portas, fim fim
- Na descida : desce cada andar, verificando se está em um andar selecionado den-
tro ou fora do elevador. Isso é feito até chegar ao andar mais baixo selecionado
dentro ou fora do elevador
enquanto não chegar ao andar mais baixo selecionado interna/externamente faça início desça um andar, se o andar foi selecionado interna/externamente então início pare, abra as portas, feche as portas, fim fim
O comando enquanto caracteriza-se por uma verificação de encerramento de atividades
antes de se iniciar (ou reiniciar) a execução de seu bloco de instruções. Dessa forma,
no algoritmo do elevador, antes de subir/descer um andar é verificado se o andar atual
é o mais alto/baixo selecionado. Caso não seja, um conjunto de atividades é executado
(sobe/desce um andar, verifica se é um andar selecionado e abre (ou não) as portas).
Vejamos sua sintaxe:
enquanto faça <bloco de instruções> <continuação do algoritmo>
Voltemos ao exemplo do aluno de castigo. Fazer um algoritmo que escrevesse para ele,
cem vezes, “Não vou fazer mais bagunça”, antes deste capítulo, seria uma tarefa inglória.
O algoritmo seria semelhante ao descrito a seguir.
Algoritmo Lição_Aluno_Versão início escreva (“Não vou fazer mais bagunça!”); escreva (“Não vou fazer mais bagunça!”); escreva (“Não vou fazer mais bagunça!”); escreva (“Não vou fazer mais bagunça!”); ... { O comando precisa ser escrito 100 vezes... } fim
Capítulo 4 • Comandos de Repetição 63
início 4 escreva (“Entre com um valor: ”); 5 leia (valor); 6 soma soma + valor; 7 contador contador + 1; { A cada iteração, conta-se mais 1 } fim 8 média soma / contador; 9 escreva (“Soma: “, soma); 10 escreva (“Média: ”, média); fim
É interessante verificar o processo de acumulação de valores feito na variável soma
(linha 6). Seu valor é atualizado a cada iteração, somando-se seu valor atual com o
novo valor lido. Para que isso funcione, é importante que o valor inicial da variável seja
definido antes da entrada do laço, para que um valor desconhecido não seja atribuído
na primeira iteração do laço.
Vejamos o teste de mesa para a melhor compreensão do processo. Para viabilizar a
realização do teste de mesa, consideremos o laço até 3 e não até 100, como está no
algoritmo (Tabela 4.1).
Entrada: 5, 4, 9 (ou seja, os valores que serão entrados pelo usuário serão 5, 4 e 9, nesta
seqüência).
Tabela 4.1 – Teste de mesa para Soma_Média
Instrução Linha contador valor^ soma^ média
2 2 0?^0?
5 5 0 [5] 0?
10 5 1 [4] 5?
15 5 2 [9] 9?
64 Algoritmos e Programação
Note que a condição de entrada/saída do laço está na linha 3. Esse teste é executado nas
instruções 3, 8, 13 e 18. Perceba também que o teste é repetido sempre após o bloco de
instruções (linha 7) pertencente ao laço. Quando a condição é verdadeira, a instrução a
ser executada é a do início do bloco, na linha 4 (instruções 4, 9 e 14). Porém, na instrução
18, a condição é falsa (no nosso teste, estamos considerando enquanto contador < 3 )
e a próxima instrução a ser executada (instrução 19) está na linha 8, após o bloco de
instruções pertencente ao comando enquanto.
Exercício proposto
1. Adapte o algoritmo Soma_Média100 para que o número de valores a ser computado
seja determinado a partir de uma variável de entrada e não como um valor fixo no
programa, como fora definido.
4.1.3 Problema 13 – Calcular a multiplicação de dois números sem o operador ""*
Faça um algoritmo que calcule a multiplicação de dois números inteiros sem utilizar o
operador “*”. Em vez disso, utilize apenas o operador de adição “+”.
Para implementar esse algoritmo, devemos lembrar que qualquer multiplicação pode
ser expressa por meio de somas. Por exemplo, o resultado da expressão 6 * 3 é o mesmo
de 6 + 6 + 6 ou 3 + 3 + 3 + 3 + 3 + 3. Ou seja, soma-se um elemento com ele próprio o
número de vezes do segundo elemento.
Algoritmo Mult_Soma var contador: inteiro ; operando1, operando2, resultado, contador: inteiro ; início 1 contador 0; { Nenhuma iteração foi feita até aqui } 2 resultado 0; { Ainda não foi somado nenhum valor } 3 escreva (“Entre com o primeiro valor: ”); 4 leia (operando1); 5 escreva (“Entre com o segundo valor: ”); 6 leia (operando2); 7 enquanto (contador < operando2) faça { O bloco será repetido “operando2” vezes } início 8 resultado resultado + operando1; 9 contador contador + 1 ; { A cada iteração, conta-se mais 1 } fim 10 escreva (“O resultado da multiplicação é: “,resultado); fim
Exercícios propostos
1. Faça três testes de mesa para o algoritmo anterior com as seguintes entradas: 0, 3;
3, 6 e 6, 3.
66 Algoritmos e Programação
Note que o valor inicial de fat é 1 e não 0, como se poderia imaginar. Isso porque o ele-
mento neutro na multiplicação é o 1 e não o 0, como na adição, ou seja, qualquer número
multiplicado por 1 é ele próprio, assim como acontece com o 0 em relação à adição.
O fatorial de 1 ou 0 é calculado implicitamente, já que nesses casos o laço não é exe-
cutado, pois a condição de controle do laço (n > 1) não é satisfeita nenhuma vez e o
valor do fatorial permanece em 1, como esperado. Esta situação ilustra o fato de que o
bloco de instruções pertencente ao laço pode não ser executado nenhuma vez, caso a
condição de controle não seja satisfeita na primeira passagem.
Exercício proposto
1. Faça dois testes de mesa referentes ao algoritmo Fatorial para o cálculo do fatorial
dos números 1 e 5.
4.2 Comandos de repetição combinados com comandos de condição
A utilização de comandos de repetição combinados com comandos de condição permite
resolver problemas bem mais complexos que os vistos até agora. Na realidade, o ferra-
mental já apresentado é a base para toda a seqüência de algoritmos, e sua compreensão é
absolutamente fundamental para o desenvolvimento de algoritmos mais sofisticados.
Os comandos de condição podem fazer parte de blocos pertencentes a comandos de
repetição e vice-versa. Ou seja, estruturas como as descritas a seguir podem ocorrer
intercaladas quantas vezes forem necessárias.
Exemplo:
se então início ... enquanto faça início ... fim ... fim { Fim do bloco se } senão início ... enquanto faça início ... se então início .... fim senão
Capítulo 4 • Comandos de Repetição 67
início .... fim .... fim { Fim do bloco enquanto } .... fim { Fim do bloco senão } <continuação do algoritmo> fim
Na estrutura anterior temos comandos de decisão aninhados a comandos de repetição
e vice-versa. Esse tipo de estrutura é extremamente útil para resolver problemas em
diversas situações. Vejamos a seguir alguns exemplos.
4.2.1 Problema 15 – Calcular a soma dos números ímpares de um intervalo
Faça um algoritmo que calcule a soma de todos os números ímpares dentro de uma
faixa de valores determinada pelo usuário.
Um número é ímpar quando sua divisão por 2 não é exata, ou seja, o resto resultante da
divisão inteira do número por 2 tem valor 1. Vejamos como fica o código:
se ((número resto 2) = 1) então <código para número ímpar> [senão <código para número par> ]
Como o algoritmo solicita a soma dos valores ímpares dentro de uma faixa, teremos
que fazer o acúmulo do resultado apenas quando a condição ímpar for atendida. Essa
condição será testada para todos os números dentro da faixa, por meio de um laço.
Algoritmo Soma_Ímpares_Versão var inferior, superior, num, soma: inteiro ; início soma 0; escreva (“Entre com o limite inferior: “); leia (inferior); escreva (“Entre com o limite superior: “); leia (superior); num inferior; enquanto (num <= superior) faça início se (num resto 2 = 1) então soma soma + num; num num + 1; fim escreva (“Somatório: “, soma); fim
Capítulo 4 • Comandos de Repetição 69
divisor número – 1; enquanto ( não (divisível) e divisor > 1) faça início se (número resto divisor = 0) então divisível V; senão divisor divisor – 1; fim se ( não (divisível)) então escreva (“O número “, número, “ é primo.”); senão escreva (“O número “, número, “ não é primo.”); fim
Apesar de o algoritmo Primo_Versão1 ser eficaz, visto que resolve o problema para o
qual foi projetado, não se pode dizer que seja propriamente eficiente. Basta que anali-
semos com um pouco mais de profundidade que perceberemos que várias otimizações
podem ser aplicadas ao raciocínio utilizado nesse algoritmo. Vejamos:
1. Números pares (com exceção do 2) não podem ser primos, visto que são divisíveis por
2. Se um número não for divisível por 2, não será divisível por nenhum outro número
par. Portanto, com exceção do número 2, só precisaremos testar números ímpares.
2. É mais fácil que um número seja divisível por um número pequeno do que por um
número maior. Portanto, se iniciarmos a procura do divisor de baixo para cima, ao
invés de cima para baixo, como foi implementado, teremos chance de encontrar o
número muito antes.
3. Nenhum número pode ser divisível por outro número maior que a metade dele.
Portanto, não precisamos testar a divisibilidade dos número na faixa entre a metade
e o próprio número.
Se levarmos em conta tais considerações, teremos um algoritmo muito mais eficiente que
o anterior, pois executará muito menos instruções para responder a mesma questão.
Algoritmo Primo_Versão var número, divisor: inteiro ; divisível: booleano ; início escreva (“Entre com um número a ser testado: ”); leia (número); divisível F; se (número resto 2 = 0 e número > 2) então { Número par diferente de 2 } divisível V; senão divisor 3; { Esta condição será falsa se o número for par } enquanto ( não (divisível) e divisor <= número / 2) faça { Números ímpares menores que 6 são primos e não precisam entrar no laço }
70 Algoritmos e Programação
início se (número resto divisor = 0) então divisível V; senão divisor divisor + 2; { Serão testados divisores ímpares: 3, 5.. } fim se ( não (divisível)) então escreva (“O número “, número, “ é primo.”); senão escreva (“O número “, número, “ não é primo.”); fim
Um raciocínio mais sofisticado pode ainda nos dar uma otimização final. Vejamos alguns
exemplos para facilitar a compreensão deste ponto:
- 15 é divisível pelos números 1, 3, 5 e 15 (1 * 15, 3 * 5, 5 * 3 e 15 * 1).
- 16 é divisível pelos números 1, 2, 4, 8 e 16 (1 * 16, 2 * 8, 4 * 4, 8 * 2 e 16 * 1).
- 17 é divisível pelos números 1 e 17 (1 * 17, e 17 * 1).
- 20 é divisível pelos números 1, 2, 4, 5, 10 e 20 (1 * 20, 2 * 10, 4 * 5, 5 * 4, 10 * 2 e 20 * 1).
- 25 é divisível pelo números 1, 5 e 25 (1 * 25, 5 * 5 e 25 * 1).
- 36 é divisível pelo números 1, 2, 3, 4, 6, 9, 12, 18 e 36 (1 * 36, 2 * 18, 3 * 12, 4 * 9, 6 * 6,
9 * 4, 12 * 3, 18 * 2 e 36 * 1).
Os exemplos anteriores são para ilustrar a seguinte propriedade da divisibilidade de
um número: qualquer número que seja divisível por outro terá como divisores dois nú-
meros ou fatores, e um será maior que o outro, a não ser que tais números sejam iguais
(quando o número tem uma raiz quadrada exata). No caso de divisores diferentes, o
número menor sempre será menor que a raiz quadrada do resultado da multiplicação e
o número maior, maior que a raiz quadrada do número em questão.
Podemos perceber que quanto maior um dos fatores, menor o outro. A relação se in-
verte após a linha da raiz quadrada, quando os números se repetem em ordem inversa.
Podemos, então, concluir que se um número não for divisível por um número menor
ou igual à sua raiz quadrada, não terá outro divisor que não ele próprio ou o 1. Ou seja,
será um número primo. Portanto, só precisamos testar a divisibilidade de um número
por valores iguais ou inferiores à sua raiz quadrada. Adaptando o algoritmo, teremos o
que se vê no exemplo a seguir.
Algoritmo Primo_Versão var número, divisor: inteiro ; divisível: booleano ;
72 Algoritmos e Programação
De fato, podemos ter tantos laços encadeados quanto precisarmos. E ainda podemos
tê-los combinados com comandos de decisão e assim por diante.
Até agora, usamos os laços para fazer operações sobre um conjunto de elementos. Por
exemplo, no caso da soma dos números primos, tínhamos que executar um bloco de
condição para cada possível divisor do número em questão. No caso da soma de 100
números, os números entrados eram acumulados dentro do laço, repetindo-se o pro-
cesso para cada número.
A utilização de laços encadeados pode ser necessária quando precisamos fazer uma
operação repetitiva para cada elemento dentro de um conjunto. Imaginemos que preci-
sássemos calcular a média das notas de uma classe. Até aí, um único laço seria suficiente.
Porém, imaginemos agora que precisássemos calcular a média das notas de todas as
turmas de uma escola. As turmas são um conjunto. As notas dos alunos dentro de cada
turma são outro conjunto. Para cada conjunto, precisaríamos de um laço, nesse caso, dois
laços encadeados. E se precisássemos ainda fazer o cálculo para todas as escolas de uma
cidade. Nesse caso precisaríamos de três laços encadeados (escolas/turmas/alunos).
4.3.1 Problema 17 – Calcular a média das turmas de uma escola
Faça um algoritmo que calcule a média de todas as turmas de uma escola. Considere
como entradas o número de turmas e o número de alunos de cada turma. A média de
cada turma deve ser apresentada, além da média geral, que será o resultado da média
das turmas.
Um detalhe importante de se notar na resolução desse tipo de algoritmo é o fato de os
laços geralmente terem condições diferentes e independentes. Podemos até mesmo resol-
ver um exercício de cada vez, abstraindo um dos laços e se concentrando no segundo.
Vejamos, então, a solução do problema para apenas uma turma, para depois resolvermos
o problema de todas as turmas:
Algoritmo Média_Turma var cont, alunos: inteiro ; nota, soma, média: real ; início 1 cont 0; { Nenhuma iteração foi feita até aqui } 2 soma 0; { Ainda não foi somado nenhum valor } 3 escreva (“Entre com o número de alunos”); 4 leia (alunos); 5 enquanto (cont < alunos) faça { Será repetido para cada aluno da turma } início 6 escreva (“Entre com a nota do aluno: ”, cont + 1); 7 leia (nota);
Capítulo 4 • Comandos de Repetição 73
8 soma soma + nota; 9 cont cont + 1; fim 10 média soma / alunos; 11 escreva (“A média da turma é: ”, média); fim
Agora, vamos resolver o que seria o cálculo das médias de uma escola, considerando
que temos as médias de cada turma já preparadas pelo usuário.
Algoritmo Média_Escola_Versão var cont, turmas: inteiro ; média_turma, soma, média_escola: real ; início 1 cont 0; { Nenhuma iteração foi feita até aqui } 2 soma 0; { Ainda não foi somado nenhum valor } 3 escreva (“Entre com o número de turmas: ”); 4 leia (turmas); 5 enquanto (cont < turmas) faça { Será repetido para cada turma } início 6 escreva (“Entre com a média da turma: ”, cont + 1); 7 leia (média_turma); 8 soma soma + média_turma; 9 cont cont + 1 ; fim 10 média_escola soma / turmas; 11 escreva (“A média da escola é: ”, média_escola); fim
Bem, resolvemos as duas partes do algoritmo. Entretanto, a parte da média das escolas
conta com uma situação que não temos: a média de cada turma não é conhecida de an-
temão pelo usuários, a não ser que estes executassem o primeiro algoritmo, anotassem
num papel o resultado de cada turma e executassem o segundo algoritmo para passar
esses valores. É claro que esta solução não é razoável.
De fato, o que precisa ser feito é substituir o trecho do segundo algoritmo em que o
usuário entra com as médias das turmas pelo primeiro algoritmo, que é quem calcula
a média de cada turma. Atenção especial deve ser dada ao possível conflito de variá-
veis. Por exemplo, os contadores utilizados nos dois algoritmos tratam de elementos
diferentes (alunos e turmas, respectivamente) e devem ser tratados como variáveis
independentes.
Algoritmo Média_Escola_Versão var cont_a, alunos, cont_t, turmas: inteiro ; nota, média_turma, soma_turma, média_escola, soma_escola: real ;
Instrução Linha cont_a alunos nota cont_t turmas média_turma soma_turma média_escola soma_escola
- Capítulo 4 • Comandos de Repetição - 14 14 1 3 7,5 0 2? 7,5? - I 15 10 1 3 7,5 0 2? 7,5? - 16 11 {1} 3 7,5 0 2? 7,5? - 17 12 1 3 [5] 0 2? 7,5? - 18 13 1 3 5 0 2? 12,5? - 19 14 2 3 5 0 2? 12,5? - I 20 10 2 3 5 0 2? 12,5? - 21 11 {2} 3 5 0 2? 12,5? - 22 12 2 3 [5,5] 0 2? 12,5? - 23 13 2 3 5,5 0 2? 18? - 24 14 3 3 5,5 0 2? 18? - I ^25 10 3 3 5,5^0 2?^18? - 26 15 3 3 5,5 0 2 6 18? - 27 16 3 3 5,5 {0} 2 {6} 18? - 28 17 3 3 5,5 0 2 6 18? - 29 18 3 3 5,5 1 2 6 18?
- E 30 5 3 3 5,5 1 2 6 18? - 31 6 0 3 5,5 1 2 6 18? - 32 7 0 3 5,5 1 2 6 0? - 33 8 0 3 5,5 {1} 2 6 0? - 34 9 0 [2] 5,5 1 2 6 0?
- I 35 10 0 2 5,5 1 2 6 0?
- 36 11 {0} 2 5,5 1 2 6 0?
- 37 12 0 2 [8] 1 2 6 0?
- 38 13 0 2 8 1 2 6 8?
- 39 14 1 2 8 1 2 6 8?
- I ^40 10 1 2 8 1 2 6 8?
- 41 11 {1} 2 8 1 2 6 8?
- 42 12 1 2 [9] 1 2 6 8?
- 43 13 1 2 9 1 2 6 17?
- 44 14 2 2 9 1 2 6 17?
- I 45 10 2 2 9 1 2 6 17?
- 46 15 2 2 9 1 2 8,5 17?
- 47 16 2 2 9 {1} 2 {8,5} 17?
- 48 17 2 2 9 1 2 8,5 17? 14,
- 49 18 2 2 9 2 2 8,5 17? 14,
- E ^50 5 2 2 9 2 2 8,5^17? 14, - 51 19 2 2 9 2 2 8,5 17 7,25 14, - 52 20 2 2 9 2 2 8,5 17 {7,25} 14,
76 Algoritmos e Programação
As linhas identificadas com E são relativas ao laço externo e as marcadas com I são
relativas ao laço interno. Note que o número de instruções executadas é bastante grande.
Isto ocorre em virtude do encadeamento dos laços, mesmo tendo usado entradas pe-
quenas (duas turmas com 3 e 2 alunos). Os custos computacionais de laços encadeados
no desempenho de algoritmos serão analisados com mais detalhes no capítulo 12.
Exercício proposto
1. Faça um algoritmo que calcule a média de todas as escolas de uma cidade. Cada
escola tem diversas turmas. Considere como entrada o número de escolas, o número
de turmas de cada escola e o número de alunos de cada turma. A média de cada
escola deve ser apresentada, além da média geral, que será o resultado da média
de todas as escolas da cidade.
4.4 Comando repita
Além do comando enquanto , existem outras estruturas para implementar laços repetiti-
vos. O comando repita funciona de forma similar ao comando enquanto , exceto pelo
fato de que a condição de controle só é testada após a execução do bloco de comandos,
e não antes, como é o caso do comando enquanto.
Vejamos sua sintaxe:
repita <bloco de instruções> até ; <continuação do algoritmo>
Assim, podemos utilizar o comando repita sempre que tivermos certeza de que o bloco
de instruções será executado ao menos uma vez, sem a necessidade do teste na entrada
do bloco. Vejamos um exemplo:
4.4.1 Problema 18 (adaptação do problema 15)
Faça um algoritmo que calcule a soma dos números ímpares entre 1 e um limite superior
definido pelo usuário.
Algoritmo Soma_Ímpares_Versão var superior, num, soma: inteiro ; início 1 soma 0; 2 escreva (“Entre com o limite superior: “); 3 leia (superior); 4 num 1;
78 Algoritmos e Programação
Exercícios propostos
1. Faça a multiplicação apenas por meio de somas (utilize o comando repita).
2. Faça um algoritmo que determine se um número é primo (utilize o comando
repita).
4.5 Comando para
Se analisarmos os exemplos de utilização de laços, perceberemos que a maioria deles
tem comportamento similar. Uma situação inicial, definida antes do início do laço como
uma preparação para a sua entrada, um teste de controle para a entrada/saída do bloco
e uma instrução dentro do laço que, em algum momento, fará com que a condição de
controle seja atingida e o laço se encerre no momento oportuno.
Vejamos um exemplo:
Algoritmo Soma_Ímpares_Versão var inferior, superior, num, soma: inteiro ; início soma 0; escreva (“Entre com o limite superior: “); leia (superior); num 1; { Situação inicial, ou preparação para a entrada no laço } enquanto (num <= superior) faça { Teste de entrada/saída } início se (num resto 2 > 0) então soma soma + num; num num + 1; { Instrução utilizada para que a condição de controle seja atingida } fim fim
O comando para procura resumir essas três características comuns à maioria das im-
plementações de laços em uma só instrução, facilitando assim a construção típica de
laços.
A sintaxe do comando para :
para (<instrução1 de preparação> [, <instrução2 de preparação> ...]; <condição1 de controle>[, <condição 2 de controle>...]; <passo para alcance da condição>) faça <bloco de instruções> <continuação do algoritmo>
Portanto, temos a separação do comando em três cláusulas: preparação, condição e
passo.
Capítulo 4 • Comandos de Repetição 79
Vale citar que, quando temos mais de uma instrução de preparação (primeira cláusula),
estas são separadas por vírgula e executadas na ordem em que se encontram no comando.
Quando temos mais de uma condição de controle (segunda cláusula), os testes também
são realizados em ordem, e a condição toda é Verdadeira apenas se todas as condições
o forem. Ou seja, é equivalente a uma condição lógica ligada pelo conectivo e. Não há
como representar composição de condições ou no comando para. Nesse caso, deve-se
obrigatoriamente fazer uso dos comandos enquanto ou repita.
Algumas linguagens de programação não implementam explicitamente a terceira cláusula
(passo), e esta tem, nesses casos, um comportamento implícito sempre igual. No caso
da linguagem Pascal, por exemplo, o passo sempre é o incremento/decremento em 1 à
variável preparada na primeira cláusula. Nesses casos, em geral, o para é usado quase
que exclusivamente em algoritmos com contadores. Já a linguagem de programação C
implementa todas as cláusulas do comando para.
O comando para é executado da seguinte maneira:
1. Execute a instrução de preparação na primeira iteração do laço.
2. Execute o teste de controle. Caso seja Verdadeiro, passe para o item 3. Caso contrário,
passe para o item 6.
3. Execute o bloco de instruções.
4. Execute o passo para alcance da condição de controle.
5. Passe para o item 2.
6. Saia do laço e prossiga o algoritmo.
O comando para é equivalente à seguinte estrutura:
<instrução de preparação> enquanto () faça início <instruções> fim
Implementemos novamente o algoritmo Soma_Ímpares_Versão1 utilizando o comando
para em vez do comando enquanto :
Algoritmo Soma_Ímpares_Versão var superior, num, soma: inteiro ; início 1 soma 0; 2 escreva (“Entre com o limite superior: “);
