EC Capitulo6

Prévia do material em texto

Sumário 
 
CAPÍTULO 6 – COMANDOS DE REPETIÇÃO____________________________ 74 
6.1 – INTRODUÇÃO ______________________________________________________74 
6.2 – REPETIÇÃO COM TESTE NO INÍCIO ( Enquanto .. faça )_________________74 
6.3 - CONTADORES E ACUMULADORES ________________________________77 
6.4 – REPETIÇÃO COM TESTE NO FINAL ( Repita .. até)______________________81 
6.5 – DIFERENÇAS DE “ENQUANTO FAÇA” e “REPITA ATÉ”________________84 
6.6 - CONCEITO DE FLAG (bandeira sinalizadora) _________________________84 
6.7 – REPETIÇÃO COM VARIÁVEL DE CONTROLE ( Para ... faça )____________85 
6.8 – COMPARAÇÃO ENTRE ESTRUTURAS DE REPETIÇÃO________________87 
 
 
 
 74 
CAPÍTULO 6 – COMANDOS DE REPETIÇÃO 
 
 
6.1 – INTRODUÇÃO 
 Existem ocasiões que é necessário efetuar a repetição de um trecho de programa 
um determinado número de vezes. Nesse caso, poderá ser criado um looping que efetue o 
processamento de um determinado trecho, tantas vezes quantas forem necessárias. Os 
loopings também são chamados de: laços de repetição ou malhas de repetição. 
 Neste capítulo serão estudados os laços de repetição ou malhas de repetição. Serão 
abordados os comandos “enquanto faça”, “repita até” e “para faça”. 
 
 
6.2 – REPETIÇÃO COM TESTE NO INÍCIO ( Enquanto .. faça ) 
 Consiste numa estrutura de controle do fluxo lógico que permite executar diversas 
vezes um mesmo trecho do algoritmo, porém, sempre verificando antes de cada execução 
se é “permitido” repetir o mesmo trecho. 
 Para realizar a repetição com teste no início, utilizamos a estrutura enquanto, que 
permite que um bloco ou uma ação primitiva seja repetida enquanto uma determinada 
<condição> for verdadeira. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Quando o resultado de <condição> for falso, o comando é abandonado. Se já da 
primeira vez o resultado for falso, os comandos não são executados nenhuma vez. 
 
Enquanto <condição> faça 
 
 Comando 1; 
 Comando 2; 
 . 
 . 
Comando n; 
 
 
Fim_enquanto; 
<condição> 
 
 
<bloco de instrução> 
N 
S 
 
 75 
 
 
 
 
 
 
 
 
 
Para inserir o cálculo da média dos alunos em um laço de repetição – utilizando a 
estrutura enquanto – que <condição> utilizaríamos? 
 A condição seria que a quantidade de médias calculadas fosse menor ou igual a 50; 
porém, o que indica quantas vezes a média foi calculada? A estrutura (enquanto) não 
oferece este recurso; portanto, devemos estabelecer um modo de contagem, o que pode ser 
feito através de um contador representado por uma variável com um dado inicial, o qual é 
incrementado a cada repetição. 
 Exemplo (contador): 
 Inteiro CONTADOR; 
 CONTADOR � 17; { inicializar o contador } 
 CONTADOR � CONTADOR + 1; { incrementar o contador de 1 } 
 
 Aplicando estes conceitos, temos: 
Início 
 { declaração de variáveis } 
 real N1, N2, N3, N4; { notas bimestrais } 
 real MA; { média anual } 
 inteiro CONTADOR; { CONTADOR } 
 CONTADOR � 0; 
 ENQUANTO CONTADOR < 50 FAÇA { teste da condição } 
 Leia (N1, N2, N3, N4); 
 MA � (N1 + N2 + N3 + N4) / 4; 
 Escreva (“Media Anual = “, MA); 
 SE MA >= 6 então 
 Início { bloco verdade } 
 Escreva (“Aluno Aprovado!”); 
 Escreva (“Parabéns!”); 
 Fim; { bloco verdade } 
 
 
 76 
 Senão 
 Início { bloco falso } 
 Escreva (“Aluno Reprovado!”); 
 Escreva (“Estude Mais!”); 
 Fim; { bloco falso } 
 Fim_se; 
 CONTADOR � CONTADOR + 1; 
 FIMENQUANTO; 
Fim. 
 
 Numa variação do exemplo anterior, poderíamos calcular a média geral da turma, 
que seria a média aritmética das 50 médias anuais, utilizando uma expressão matemática 
gigantesca: 
 (M1 + M2 + M3 + M4 + M5 + ... + M49 + M50) / 50; 
o que se tornaria inviável. Podemos utilizar nessa situação as vantagens dos loops, fazendo 
um laço de repetição que a cada execução acumule em uma variável, chamada 
acumulador, o somatório das médias anuais de cada aluno. Após o término da repetição, 
teríamos a soma de todas as médias, na variável de acumulação, restando apenas dividi-la 
pela quantidade de médias somadas (50). 
 Exemplo (acumulador): 
 Inteiro CONT, { contador } 
 ACUM; { acumulador } 
 ACUM � 17; { inicializar o acumulador } 
 Leia (CONT); 
 ACUM � ACUM + CONT; { somar no acumulador o contador } 
 Execute mais algumas vezes estas duas últimas ações, observando o que acontece 
com a variável ACUM. 
 início 
 { declaração de variáveis } 
 real media_anual, acum, { acum = acumulador } 
 media_anual_turma; 
 inteiro contador; 
 contador � acum � 0; 
 ENQUANTO contador < 50 faça { teste de condição } 
 Leia (media_anual); 
 acum � acum + media_anual; 
 contador � contador + 1; 
 
 77 
 FIMENQUANTO; 
 media_anual_turma � acum / 50; 
 escreva (“media anual da turma = “, media_anual_turma); 
 fim. 
 O algoritmo anterior utilizava um pré-conhecimento da quantidade de alunos da 
turma da qual se desejava a média geral. Se não soubéssemos quantos eram os alunos, o 
que faríamos para controlar o laço de repetição? Teremos de encontrar outro critério de 
parada, o que pode ser feito utilizando um valor predefinido como finalizador de uma 
seqüência de valores. 
 Para aplicar tal conceito ao algoritmo da média geral da turma usaremos como 
finalizador o valor –1, que quando encontrado encerra o laço sem ter seu valor computador 
ao acumulador. 
 início 
real media_anual, acum, media_anual_turma; 
inteiro contador; 
acum � 0; 
escreva (“Para finalizar o algoritmo deve-se informar –1 para a média anual”); 
leia (media_anual); 
ENQUANTO media_anual <> -1 faça 
 acum � acum + media_anual; 
 leia (media_anual); 
 contador � contador + 1; 
FIMENQUANTO; 
Media_anual_turma � acum / contador; 
Escreva (“media anual da turma = “, media_anual_turma); 
 fim. 
 
 
6.3 - CONTADORES E ACUMULADORES 
 
Juntamente com as instruções de repetição aparece o conceito de acumuladores e 
contadores. 
Acumuladores e contadores são variáveis com um propósito específico: 
Acumuladores : acumulam um valor a cada passo de repetição do laço, normalmente é 
utilizado para cálculos; 
Contadores: contam a quantidade de repetições de execução de um determinado laço. 
São sempre incrementadas de uma unidade de valor. 
 
 78 
Um exemplo de contador pode ser descrito no algoritmo abaixo: deseja-se saber ao final 
do algoritmo quantos nomes foram lidos: 
{ ALGORITMO EXEMPLOENQUANTO } 
 INICIO 
CARACTER NOME ; 
INTEIRO CONT:; 
 
 CONT � 0; {INICIALIZA O CONTADOR COM ZERO} 
 LEIA (NOME); 
 CONT � CONT + 1; 
 ENQUANTO (NOME <> “FIM”) FAÇA 
 ESCREVA (NOME); 
 LEIA (NOME); 
 CONT ���� CONT + 1; 
 FIM ENQUANTO; 
 ESCREVA (“FORAM LIDOS”, CONT, “ NOMES”); 
 FIM. 
 
O princípio básico do contador e do acumulador é inicializar o valor dos mesmos 
e atribuir a variável, o valor já contido nela somado de um incremento. 
 
Todo contador ou acumulador deve receber um valor inicial 
 
Exemplo: 
 
CONTADOR � 0; 
CONTADOR � CONTADOR + 1; 
 
SOMA � 0; 
SOMA � SOMA + 10; 
 
 79 
EXERCÍCIO DE APRENDIZAGEM 
 Considere o seguinte problema: “Elaborar o algoritmo através da linguagem natural, 
diagrama de blocos e codificação em pseudocódigo (português estruturado) de um 
programa que efetue o cálculo do fatorial do número 5, 5!”. Dessa forma, temos que 5! = 5 * 
4 * 3 * 2 * 1 ou 5! = 1 * 2 * 3 * 4 * 5, equivalente a 120. 
 Fatorial é o produto dos números naturais desde 1 até o inteiro n. Sendo assim, o 
cálculo de uma fatorial é conseguido pela multiplicaçãosucessiva do número de termos. No 
caso de uma fatorial de número 5, este é o número de termos a ser utilizado. Desta forma, o 
programa deverá executar as multiplicações sucessivamente e acumulá-las a fim de possuir 
o valor 120 após 5 passos. O número de passos deverá ser controlado por um contador. 
Veja a seguir: 
 
Algoritmo 
1. Inicializar as variáveis FATORIAL e CONTADOR com 1; 
2. Multiplicar sucessivamente a variável FATORIAL pela variável CONTADOR; 
3. Incrementar 1 à variável CONTADOR efetuando o controle até 5; 
4. Apresentar ao final o valor obtido. 
Pelo fato de se ter que efetuar o cálculo de uma fatorial de 5 (5!), isto implica que o 
contador deverá variar de 1 a 5, por este motivo a variável CONTADOR deverá ser 
inicializada com valor 1. 
Pelo fato de a variável FATORIAL possuir ao final o resultado do cálculo do fatorial 
pretendido, esta deverá ser inicializada com valor 1. Se ela for inicializada com zero, não 
existirá resultado final, pois qualquer valor multiplicado por zero resulta zero. 
Multiplicar sucessivamente implica em se efetuar a multiplicação de variável 
CONTADOR com o valor atual da variável FATORIAL a cada passo controlado pelo looping. 
No caso por 5 vezes. Abaixo é indicado esta ocorrência na linha 2 do algoritmo. 
 
1. Inicializar as variáveis FATORIAL e CONTADOR com 1; 
2. Repetir a execução dos passos 3 e 4 por 5 vezes; 
3. FATORIAL � FATORIAL * CONTADOR; 
4. Incrementar 1 à variável CONTADOR; 
5. Apresentar ao final o valor obtido. 
 
 
 
 
 
 80 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Observe dentro do looping a indicação de dois contadores, sendo que o primeiro 
funciona como um acumulador, pois é este que terá no final o valor do resultado da fatorial, 
e o segundo sendo utilizado para controlar a execução do looping e ser a base para o 
cálculo do acumulador. 
 
CONTADOR FATORIAL FATORIAL � FATORIAL * 
CONTADOR 
COMENTÁRIOS 
1 1 1 Valor inicial das variáveis e da fatorial 
2 1 2 Cálculo da fatorial com o contador em 2 
3 2 6 Cálculo da fatorial com o contador em 3 
4 6 24 Cálculo da fatorial com o contador em 4 
5 24 120 Cálculo da fatorial com o contador em 5 
 
Perceba que quando a variável CONTADOR está com valor 5, a variável FATORIAL 
está com o valor 120. Neste ponto, o looping é encerrado e é apresentado o valor da 
variável FATORIAL. 
Início 
Fatorial � 1 
Contador � 1 
Contador 
<= 5 
Fatorial � Fatorial * 
Contador 
Contador � 
Contador + 1 
S 
N 
Fatorial 
Fim 
Diagrama de Blocos 
 
 81 
 
Pseudocódigo (Português Estruturado) 
Início 
 inteiro CONTADOR, FATORIAL; 
 FATORIAL � 1; 
 CONTADOR � 1; 
 Enquanto (CONTADOR <= 5) Faça 
 FATORIAL � FATORIAL * CONTADOR; 
 CONTADOR � CONTADOR + 1; 
 Fimenquanto; 
 Escreva (“Fatorial de 5 é = “, FATORIAL); 
Fim. 
 
 Vamos reescrever o algoritmo do fatorial, mas agora possibilitando fornecer qualquer 
número, para que o mesmo seja calculado. 
Início 
 inteiro CONTADOR, FATORIAL, NUMERO; 
 FATORIAL � 1; 
 CONTADOR � 1; 
Leia (NUMERO); 
 Enquanto (CONTADOR <= NUMERO) Faça 
 FATORIAL � FATORIAL * CONTADOR; 
 CONTADOR � CONTADOR + 1; 
 Fimenquanto; 
 Escreva (“Fatorial de “, NUMERO, “ é = “, FATORIAL); 
Fim. 
 
6.4 – REPETIÇÃO COM TESTE NO FINAL ( Repita .. até) 
 Para realizar a repetição com teste no final, utilizamos a estrutura repita, que permite 
que um bloco ou ação primitiva seja repetido até que uma determinada condição seja 
verdadeira. 
 
 
 
 
 
 
 
 
 
Laço com no mínimo um ciclo 
 
 
<bloco de instrução> 
<condição> 
 
N 
S 
Repita 
 Comando 1; 
 Comando 2; 
 . 
 . 
 Comando n; 
 
Até <condição> 
 
 82 
 Pela sintaxe da estrutura, percebemos que o bloco (Comando 1 ... Comando n) é 
executado pelo menos uma vez, independente da validade da condição. Isto ocorre porque 
a inspeção da condição é feita após a execução do bloco. 
 
 
 
 
 
 
 
Exemplos: 
a) início 
{ declaração de variáveis } 
real media_anual, acumulador, media_anual_turma; 
inteiro contador; 
contador � 0; 
acumulador � 0; 
repita 
 leia (media_anual); 
 acumulador � acumulador + media_anual; 
 contador � contador+ 1; 
até contador >= 50; { teste da condição } 
media_anual_turma � acumulador / 50; 
escreva (“media anual da turma = “, media_anual_turma); 
fim. 
 A utilização de uma estrutura repita no lugar de uma estrutura enquanto corresponde 
a utilizar como <condição> para o repita a negação da <condição>do enquanto. 
 
 
 83 
 
b) Construa um algoritmo que permita fazer um levantamento do estoque de vinhos de 
uma adega, tendo como dados de entrada tipos de vinho (branco, tinto e rose). 
Especifique a porcentagem de cada tipo sobre o total geral de vinhos; a quantidade de 
vinhos é desconhecida (usar como finalizador a constante “fim”). 
 
Início 
 caractere tipo_vinho; 
 inteiro cont_vinhos, cont_tinto, cont_branco, cont_rose; 
 real perc_tinto, perc_branco, perc_rose; 
 cont_vinhos � cont_tinto � cont_branco � cont_rose � 0; 
 repita 
 leia (tipo_vinho); 
 escolha tipo_vinho 
 caso “tinto”: cont_tinto � cont_tinto + 1; 
 caso “branco”: cont_branco � cont_branco + 1; 
 caso “rose”: cont_rose � cont_rose+ 1; 
 fimescolha; 
 cont_vinhos� cont_vinhos + 1; 
 até tipo_vinho = “fim”; 
 cont_vinhos � cont_vinhos – 1; 
 se cont_vinhos > 0 então 
 início 
 perc_tinto � cont_tinto * 100 / cont_vinhos; 
 perc_branco � cont_branco * 100 / cont_vinhos; 
 perc_rose � cont_rose * 100 / cont_vinhos; 
 escreva (“porcentagem de tintos = “, porc_tinto); 
 escreva (“porcentagem de brancos = “, porc_branco); 
 escreva (“porcentagem de roses = “, porc_rose); 
 fim; 
 senão 
 escreva (“nenhum tipo foi fornecido!”); 
 fimse; 
fim. 
 
c) Voltemos ao cálculo do fatorial do número 5. 
Início 
 inteiro CONTADOR, FATORIAL; 
 FATORIAL � 1; 
 CONTADOR � 1; 
 repita 
 FATORIAL � FATORIAL * CONTADOR; 
 CONTADOR � CONTADOR + 1; 
 até CONTADOR > 5; 
 escreva (“Fatorial de 5 é = “, FATORIAL); 
Fim. 
 
 84 
6.5 – DIFERENÇAS DE “ENQUANTO FAÇA” e “REPITA ATÉ” 
 
É importante saber diferenciar as instruções para saber quando utiliza-las. No 
enquanto, a condição é verificada antes de qualquer instrução contida no bloco ser 
executada, isto significa que, se a condição não for satisfeita na primeira execução, as 
instruções contidas no bloco não serão executadas nenhuma vez. Para o repita, é 
necessária a execução, de pelo menos uma vez, do bloco de instruções para poder testar a 
condição, pois a condição sempre é tentada no final da instrução, ao contrário do enquanto 
que testa a condição no início. 
Verifique os algoritmos de exemplo de cada uma das instruções e veja as diferenças 
do resultado obtido para o mesmo conjunto de valores. 
 
6.6 - CONCEITO DE FLAG (bandeira sinalizadora) 
 
Um Flag, ou uma bandeira, é um variável sinalizadora que possibilita cria pontos de 
controle em um algoritmo de modo a otimizar um processo, marcar um estado, entre outras 
funções. O flag pode ser uma variável de qualquer tipo, desde que se estabeleça dois 
estados para a mesma, ou estado. Uma variável flag pode ser lógica, onde seus estados 
serão V ou F. 
O exemplo abaixo mostra o uso de um flag para controlar se em determinado 
momento na cadeia de caracteres digitada pelo usuário fora inserido o caracter ‘A’. A 
condição de parada do algoritmo é a leitura do caracter ‘F’. 
 
{ ALGORITMO EXEMPLO_FLAG } 
 
INICIO 
 LOGICO FLAG; 
 CARACTER LETRA; 
 
 FLAG � F; 
 REPITA 
 LEIA(LETRA); 
 ESCREVA (LETRA); 
 SE LETRA = “A” ENTAO FLAG � V; 
 ATE (LETRA = “F”); 
 SE FLAG ENTAO ESCREVA (“NAS LETRAS O (A) FOI 
 DIGITADO”); 
 FIM. 
 
O Flag sempre possui um estado inicial, definido pelo algoritmo, a troca de estado 
acontece quando uma condição de controle é satisfeita. 
 
 85 
6.7 – REPETIÇÃO COM VARIÁVEL DE CONTROLE ( Para ... faça ) 
 Nas estruturas de repetição vistas até agora, ocorrem casos em que se torna difícil 
determinar quantas vezes o bloco será executado. Sabemos que ele será executado 
enquanto uma condição for satisfeita – enquanto -, ou até que uma condição seja satisfeita 
– repita. A estrutura para repete a execução do bloco um número finito de vezes, pois ela 
possui limites fixos: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Onde: var é a variável de controle; 
 vi é o valor inicial da variável var; 
 vf é o valor final da variável var, ou seja, o valor até o qual ela pode chegar; 
 p é o valor do incremento dado à variável var. 
 Possuímos então um contador de forma compacta, em que sempre temos uma 
inicialização (vi) da variável de controle (var), um teste para verificar se a variável atingiu o 
limite (vf) e um acréscimo (incremento de p) na variável de controle após cada execução do 
bloco de repetição. 
Var � 
Início, Fim, 
Incremento 
 
Instruções 
N 
S 
Para var de vi até vf passo p faça 
 
 Comando 1; 
 Comando 2; 
 . 
 . 
 Comando n; 
 
Fimpara; 
 
 
 86 
Exemplos: 
 
a) voltemos ao cálculo da média aritmética de uma turma fixa 50 alunos. 
Início 
 real media_anual, { média anual de um dado aluno} 
 acumulador, media_anual_turma, var_controle; 
 acumulador � 0; 
 para var_controle de 1 até 50 passo 1 faça 
 leia (media_anual); 
 acumulador � acumulador + media_anual; 
 fimpara; 
 media_anual_turma � acumulador /50; 
 escreva (“media anual da turma = “, media_anual_turma); 
fim. 
 
b) Elabore um algoritmo que efetue a soma de todos os números ímpares que são 
múltiplos de três e que se encontram no conjunto dos números de 1 até 500. 
Início 
 Inteiro soma_impares, {soma dos números ímpares múltiplos de três } 
 var_controle; 
 soma_impares � 0; 
 para var_controle de 1 até 500 passo 1 faça 
 se (int (var_controle / 2) <> var_controle / 2) {o número é impar?} 
 então início 
 se (int (var_controle / 3) = var_controle / 3) {múltiplo de três?} 
 então soma_impares � soma_impares+ 1; 
 fimse; 
 fim; 
 fimse; 
 fimpara; 
 escreva (“soma = “, soma_impares); 
fim. 
 
 87 
c) Voltemos ao cálculo do fatorial do número 5. 
Início 
 inteiro CONTADOR, FATORIAL; 
 FATORIAL � 1; 
 para CONTADOR de 1 até 5 passo 1 faça 
 FATORIAL � FATORIAL * CONTADOR; 
 fimpara; 
 Escreva (“Fatorial de 5 é = “, FATORIAL); 
 Fim. 
 
6.8 – COMPARAÇÃO ENTRE ESTRUTURAS DE REPETIÇÃO 
 Podemos estabelecer dois “postulados”que relacionam as estruturas de repetição: 
• Toda estrutura Enquanto pode ser convertida para Repita e vice_versa; 
• Toda estrutura Para pode ser convertida em Enquanto, mas nem toda estrutura 
Enquanto pode ser convertida em Para. 
Temos também a seguinte tabela comparativa que relaciona as características de 
cada estrutura de repetição: 
 
Estrutura Condição Quantidade de 
Execuções 
Condição de 
Existência 
Enquanto Início ? Condição verdadeira 
Repita Final Mínimo 1 Condição falsa 
Para Não tem (vf – vi + p) div p var < vf 
 
Exemplos: 
a) elabore um algoritmo que, utilizando as três estruturas de repetição, imprima a 
tabuada do número 5. 
• Utilizando Enquanto: 
Inicio 
 inteiro contador; 
 contador � 1; 
 enquanto contador <= 10 faça 
 escreva (contador, “ x 5 = “, contador * 5); 
 contador � contador + 1; 
 fimenquanto; 
fim. 
 
 
 88 
• Utilizando Repita: 
Inicio 
 Inteiro contador; 
 contador � 1; 
 repita 
 Escreva (contador, “x 5 = “, contador * 5); 
 contador � contador + 1; 
 até contador > 10; 
Fim. 
 
• Utilizando Para: 
Inicio 
 Inteiro contador; 
 para contador de 1 até 10 passo 1 faça 
 Escreva (contador, “ x 5 = ”, contador * 5); 
 fimpara; 
Fim. 
 
b) Modifique o algoritmo para que este imprima a tabuada de quaisquer números, sendo 
que estes números são fornecidos pelo usuário, até encontrar como finalizador –1. 
Sabendo que primeiro número-base fornecido não é –1: 
• Utilizando Enquanto: 
Inicio 
 Inteiro numero, contador; 
 Leia (numero); 
 Enquanto numero <> -1 faça 
 Contador � 1; 
 Enquanto contador <= 10 faça 
 Escreva (contador, “ x “, numero, “ = “, contador * numero); 
 Contador � contador + 1; 
 Fimenquanto; 
 Leia (numero); 
 Fimenquanto; 
Fim. 
 
 
 89 
• Utilizando Repita: 
Inicio 
 Inteiro numero, contador; 
 Leia (numero); 
 Repita 
 Contador � 1; 
 Repita 
 Escreva (contador, “ x “, numero, “ = “, contador * numero); 
 Contador � contador + 1; 
 Até contador > 10; 
 Leia (numero); 
 Até numero = -1; 
Fim. 
 
• Utilizando Para: 
Inicio 
 Inteiro numero, contador, var_controle; 
 Leia (numero); 
 Para var_controle de 1 até ????? passo 1 faça 
 Contador � 1; 
 Para contador de 1 até 10 passo 1 faça 
 Escreva (contador, “ x “, numero, “ = “, contador * numero); 
 Contador � contador + 1; 
 fimpara; 
 ????? Leia (numero); ????? 
 fimpara; 
Fim. 
 
Verificamos neste exemplo o segundo “postulado”, ou seja, a impossibilidade de 
construir este algoritmo utilizando a estrutura Para. 
 
� Do Enquanto ao PARA-FAÇA 
 
Podemos verificar a diferença do enquanto e o para-faça, não somente no sentido de 
laço infinito e finito. Abaixo temos uma instrução para-faça e logo após uma instrução 
enquanto que realizam a mesma função ler 10 valores e exibir a soma dos mesmos. Com o 
para-faca, muitas coisas não precisam ser controladas como acontece no enquanto deste 
 
 90 
exemplo. No enquanto é utilizado um contador para limitar o laço, todo o controle deste 
contador deve ser realizado pelo desenvolvedor do algoritmo. No para-faça, o controle de 
contagem é feito pela própria instrução. 
 
{ ALGORITMO COM_ENQUANTO } 
 
INICIO 
 INTEIRO SOMA, CONTADOR, NUMERO; 
 
 LEIA (NUMERO); 
 CONTADOR � 1; 
 SOMA � NUMERO; 
 ENQUANTO (CONTADOR < 10) FACA 
 LEIA (NUMERO); 
 SOMA � SOMA + NUMERO; 
 CONTADOR � CONTADOR + 1; 
 FIM ENQUANTO; 
 ESCREVE (SOMA); 
FIM. 
 
 
{ ALGORITMO COM_PARA_FACA } 
 
INICIO 
 INTEIRO SOMA, CONTADOR, NUMERO; 
 
 PARA (CONTADOR � 1 ATE 10 PASSO 1) FACA 
 LEIA (NUMERO); 
 SOMA � SOMA + NUMERO; 
 FIM PARA; 
 ESCREVE (SOMA); 
FIM. 
 
 
 
1
 Material baseado na apostila da Profa Jusane Farina/Tatiana Pazeto/Sediane Lunardi