CAPÍTULO 7 - ESTRUTURAS DE CONTROLE DE ITERAÇÕES
7.1 - INTRODUÇÃO
As estruturas de controle de iterações são comuns nos algoritmos. Elas são
necessárias quando um determinado trecho do algoritmo, representando o mesmo
comportamento padrão, deve ser escrito, seqüencialmente, mais de uma vez.
Através do uso das estruturas de controle de iterações, nós escrevemos o trecho
algorítmico apenas uma vez, mas o mesmo poderá ser executado várias vezes.
Sobre o controle do número de vezes que um trecho do algoritmo deve ser
executado, cabe-nos dizer que ele poderá ser conhecido ou não.
Quando o número de vezes que um trecho de algoritmo deve ser repetido é
conhecido, dizemos que a repetição será controlada por um contador de iterações.
Quando o número de repetições exigidas é desconhecido, dizemos que a mesma será
controlada por condição de iterações.
Esteticamente, não existem diferenças entre estas duas naturezas de estrutura. As
diferenças entre elas se escondem na lógica que rege o funcionamento da ação de repetição,
ou seja, ela será mais nítida na parte dinâmica do algoritmo (quando o estivermos
executando).
Um exemplo prático destas situações, poderia ser:
A - correr 10 voltas em uma pista de atletismo; B - correr em volta de uma pista de atletismo, até chover.
Na situação A a repetição da ação correr em volta da pista está sendo controlado por
um contador que começa de zero e é incrementado de uma unidade para cada volta
completada. Quando o contador atingir o valor 10, a repetição da ação deverá ser
interrompida.
Na situação B a repetição da ação pode ser interrompida em qualquer instante entre
zero e infinitas voltas. Só depende das condições meteorológicas. Neste caso, a interrupção
da repetição da ação será feita logicamente, bastando que a cada instante o atleta verifique
as condições do tempo para continuar correndo ou não. Note que se ele entra na pista e em
seguida verificar as condições do tempo, e constatar que está chovendo, ele não correrá
nenhuma volta. Agora, por outro lado, se nunca mais chover naquele local, o atleta ficará
"eternamente" correndo em volta da pista de atletismo (entrará em looping).
7.2 - ITERAÇÕES CONTROLADAS POR CONTADOR
Vamos supor o seguinte problema: Faça um algoritmo que some os números
inteiros entre 1 e 5, inclusive.
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 75
var num1, num2, num3, num4, num5, soma : inteiro;
início leia (num1, num2, num3, num4, num5);
soma � num1 + num2 + num3 + num4 + num5;
escreva (soma);
fim.
Esta é uma solução trivial do problema dado. Note que se expandíssemos o limite
superior de 5 para 1.000.000 a solução poderia ser feita utilizando o mesmo padrão.
Entretanto, para esta nova solução você teria um "pouquinho" mais de trabalho para
construir a expressão aritmética.
Vamos tentar uma nova solução utilizando os identificador soma (ver figura 7.1), o
qual terá a função de somar os números pertencentes ao intervalo dado, e o identificador i que terá a função de gerar os números pertencentes ao intervalo um a um.
var soma, i : inteiro;
início soma � 0; {não foi somado ninguém ainda}
i � 1; {i começa representando o 1°. valor do intervalo}
soma � soma + i; {atribua a soma o valor associado a ela somado com o
valor associado a i}
i � i + 1; {obtenha o próximo valor do intervalo somando uma
unidade ao valor atual de i}
soma � soma + i; {acumule em soma o novo valor de i}
i � i + 1; {gere o próximo valor de i}
{as próximas ações são idênticas}
soma � soma + i;
i � i + 1;
soma � soma + i;
i � i + 1;
soma � soma + i;
i � i + 1;
escreva (soma);
fim.
Obviamente, se eu tivesse que fazer isto um milhão de vezes, eu escolheria o padrão
da primeira solução, por ser mais sintético que o segundo padrão de solução.
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 76
Figura 7.1 Somatório de números pertencentes a um dado intervalo.
Mas no segundo padrão, podemos notar que as instruções:
soma � soma + i;
i � i + 1;
soma � 0;
início
i � 1;
soma � soma + 1;
i � i + 1;
soma � soma + 1;
i � i + 1;
soma � soma + 1;
i � i + 1;
soma � soma + 1;
i � i + 1;
soma � soma + 1;
escreva (soma);
fim.
i � i + 1;
soma � soma + 1;
i � i + 1;
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 77
aparecem repetidas e em seqüência, apesar de em cada figuração destas instruções elas
estão manipulando valores diferentes. O uso da estrutura de iteração permitirá o mesmo
efeito que o efetuado pelas repetições textuais, com a diferença de que as instruções
repetidas, serão escritas uma única vez.
A sintaxe geral da estrutura de repetição é:
enquanto condição
faça inst1;
inst2;
inst3;
……;
instN;
onde:
enquanto faça � é a estrutura de controle de iterações.
condição � pode ser um identificador do tipo lógico, ou uma expressão relacional,
ou uma expressão lógica.
inst1; ...; instN � forma o conjunto de instruções que podem ser executadas várias
vezes.
Como condição fornecerá sempre um valor do tipo lógico, a semântica desta
estrutura é dada da seguinte forma:
Se o valor avaliado em condição for verdadeiro, então o bloco que compõe as
instruções de instl a instN é executado uma vez.
Após a primeira execução do bloco de instruções, o valor de condição é reavaliado.
Caso o seu resultado continue sendo verdadeiro, o bloco de instruções é executado
novamente, e após o seu término uma nova avaliação de condição deve ser feita. Somente
quando o valor avaliado em condição fornecer o valor falso é que este ciclo será
interrompido.
Note que, no momento em que a avaliação do valor de condição produzir o valor
falso o bloco de instruções será ignorado, e o controle de execução deverá ser desviado para
a primeira instrução após a estrutura enquanto faça.
falso
enquanto condição
faça verdadeiro
inst1;
inst2;
inst3;
........;
instN;
instX;
V
F enquanto condição
inst1;
inst2;
........;
instN;
- - - - - - - Fluxo a ser seguido
quando o valor da
condição for verdadeiro.
Fluxo a ser seguido
quando o valor da
condição for falso.
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 78
Assim o nosso algoritmo para somar os 5 primeiros números naturais, fica da seguinte
forma:
var soma, i : inteiro;
início
soma � 0;
i � l ;
enquanto i <= 5
faça soma � soma + i;
i � i + 1;
escreva (soma);
fim.
Fazendo um teste de mesa:
AÇÕES OBJETOS CONDIÇÃO
var soma, i : inteiro; soma i i <= 5 *
soma � 0; 0 - -
i � 1; 0 1 -
enquanto i <= 5 faça 0 1 verdadeiro
soma � soma + i; 1 1 -
i � i + 1; 1 2 -
enquanto i <= 5 faça 1 2 verdadeiro
soma � soma + i; 3 2 -
i � i + 1; 3 3 -
enquanto i <= 5 faça 3 3 verdadeiro
soma � soma + i; 6 3 -
i � i + 1; 6 4 -
enquanto i <= 5 faça 6 4 verdadeiro
soma � soma + i; 10 4 -
i � i + 1; 10 5 -
enquanto i <= 5 faça 10 5 verdadeiro
soma � soma + i; 15 5 -
i � i + 1; 15 6 -
início
soma � 0;
i � 1;
soma � soma + 1;
i � i + 1;
enquanto i <= 5
escreva (soma);
fim.
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 79
enquanto i <= 5 faça 15 6 falso
escreva (soma); 15 6 -
* Apesar da expressão relacional i <= 5 não ser um objeto do algoritmo, ela foi colocada no
teste de mesa devido ao fato do funcionamento da estrutura de repetição depender
diretamente do valor, a qual sofre reavaliação a cada iteração.
Agora se quiséssemos estender o limite superior para 1.000.000, basta apenas trocar
a relação i <= 5 para i <= 106.
Mas podemos generalizar ainda mais esta solução, se o limite superior da série for
um argumento de entrada.
var soma, i, n : inteiro; {n = representa o limite superior do intervalo}
início leia (n);
soma � 0;
i � 1;
enquanto i <= n
faça soma � soma + 1; {acumule em soma o valor de i}
i � i +1; {incremente uma unidade no valor de i}
escreva (soma);
fim.
Este algoritmo faz o somatório dos números inteiros positivos entre 1 e n, onde o valor de n
deve ser fornecido em tempo de execução do algoritmo.
7.3 - EXERCÍCIOS RESOLVIDOS
R.7.1 - Sendo conhecido um conjunto com 10 números inteiros, faça um algoritmo que
calcule a soma entre estes valores.
Solução: Refinamento 1
- definir os objetos necessários;
- atribuir valores iniciais;
- conhecer cada um dos valores do conjunto, um a um. E para cada valor conhecido
acumule-o no identificador soma;
- informar o valor de soma.
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 80
Refinamento 2
{objetos necessários}
- contador de iterações (i) para garantir que os 10 valores serão conhecidos e
somados;
- identificador (num) para representar cada valor do conjunto (um de cada vez);
- identificador (soma) para ser o acumulador de cada número conhecido do conjunto.
{atribuir valores iniciais}
- o identificador i é o contador de iterações. Como no conjunto têm 10 valores para
serem conhecidos e acumulados, poderemos fazer com que i comece com o valor 1,
devendo ir até 10 de um em um;
- o identificador soma é o somador dos números que estão sendo conhecidos. Como
os valores no início do processo não foram conhecidos nenhum número ainda, seu
valor inicial deve ser zero;
- o identificador num não possui valor inicial, pois ele deverá representar de um
conjunto de números, que são argumentos de entrada;
{conhecer cada um dos valores do conjunto, um a um. E para cada valor conhecido
acumule-o no identificador soma }
- enquanto i for inferior ou igual a 10, conheça um valor do conjunto, acumule-o em
soma e incremente uma unidade em i;
{informar o valor de soma}
- escreva (soma);
Refinamento 3 (ver figura 7.2)
var num, soma, i : inteiro; {como argumentos de entrada existe um conjunto de
10 números, que serão representados por num, um a
um}
início {valores iniciais}
soma � 0;
i � 1;
enquanto i <= 10
faça leia(num); {conheça um número do conjunto}
soma � soma + num; {acumule-o em soma}
i � i + 1; {incremente uma unidade em i}
escreva (soma);
fim.
Faça um teste de mesa neste algoritmo para os valores [2, 5, 3, 0, -4, 4, 8, 9, 19, 22].
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 81
Figura 7.2 Fluxograma do exercício resolvido R.7.1.
R.7.2 - Faça um algoritmo que calcule o fatorial de um número dado.
Solução: Refinamento 1
- definir os objetos necessários;
- atribuir valores iniciais;
- conhecer o valor do número para cálculo do fatorial;
- calcular o fatorial;
- informar o valor do fatorial.
Refinamento 2
O fatorial de um número n, inteiro positivo, é definido como sendo o produto entre
todos os números entre 1 e n.
n! = 1 * 2 * 3 * ... * (n - 1) * (n)
e por definição 0! = 1, 1! = 1.
início
soma � 0;
i � 1;
soma � soma + num;
i � i + 1;
enquanto i <= 10
escreva (soma);
fim.
leia (num);
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 82
Logo, o padrão de comportamento da função fatorial é:
- comece o fatorial com o valor 1;
- gerar os valores entre 1 e n, e para cada valor gerado multiplique-o com o valor
atual do fatorial, atribuindo o resultado ao próprio fatorial;
assim,
{definir os objetos necessários}
- Usaremos o identificador n para representar o número que se deseja calcular o
fatorial;
- Usaremos o identificador fat para representar o valor do fatorial;
- Usaremos o identificador i para gerar os números entre 1 e n para serem usados no
produtório;
{atribuir valores iniciais}
O padrão de comportamento do cálculo da função fatorial é:
- comece o fatorial com o valor 1;
- gerar os valores entre 1 e n, e para cada valor gerado multiplique-o com o valor
atual do fatorial, atribuindo o resultado ao próprio fatorial;
Assim, fat deve começar com 1, e i também deve começar com 1.
{conheça o valor do número para cálculo do fatorial}
leia (n);
{calcular o fatorial}
- gerar os valores entre 1 e n, e para cada valor gerado multiplique-o com o valor
atual do fatorial, atribuindo o resultado ao próprio fatorial;
{informe o valor do fatorial} escreva (fat);
Refinamento 3 (ver figura 7.3)
var n, fat, i : inteiro; {n representa o valor para cálculo do fatorial}
{fat representa o valor do fatorial de n}
início {valores iniciais}
fat � 1;
i � 1;
leia (n);
enquanto i <= n {para todo i entre 1 e n}
faça fat � fat * i; {multiplique o valor de fat com o valor de i, armazene o
resultado em fat}
i � i + 1;
escreva (fat);
fim.
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 83
TESTE DE MESA (Cálculo de 3 ! )
AÇÕES OBJETOS CONDIÇÃO
var n, fat, i : inteiro; n fat i i <= n
fat � 1; - 1 - -
i � 1; - 1 1 -
leia(n); 3 1 1 -
enquanto i <= n faça - 1 1 verdadeiro
fat � fat * i; - 1 1 -
i � i + 1; - 1 2 -
enquanto i <= n faça - 1 2 verdadeiro
fat � fat * i; - 2 2 -
i � i + 1; - 2 3 -
enquanto i <= n faça - 2 3 verdadeiro
fat � fat * i; - 6 3 -
i � i + 1; - 6 4 -
enquanto i <= n faça - 6 4 falso
escreva (fat); - 6 - -
Figura 7.3 Fluxograma do exercício resolvido R.7.2.
início
fat � 1;
i � 1;
fat � fat * i;
i � i + 1;
enquanto i <= n
escreva (fat);
fim.
leia (n);
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 84
7.4 - ITERAÇÕES CONTROLADAS POR CONDIÇÃO
A sintaxe e a semântica das estruturas de iterações controladas por contador e por
condição são idênticas. A única diferença está na forma de interrupção da repetição das
ações. Na controlada por contador está sempre prevista, já a controlada por condição, a
interrupção depende da ocorrência de determinado(s) fato(s) descritos nas instruções que
formam o bloco de instruções que está sendo repetido.
A situação, ou o conjunto de situações que provocam a interrupção do ciclo
normalmente é chamado de flag.
Quando trabalhamos com flags como forma de instrução de estruturas, devemos
tomar os seguintes cuidados:
1°.) garantir a hipótese de execução das instruções que compõe o bloco de instruções que
podem ser executadas de forma iterativa;
2°.) garantir que a execução iterativa do bloco de instruções pode ser interrompido em
qualquer instante.
Uma estrutura de repetição controlado por condição, deverá ter sempre o seguinte
aspecto:
Situação que pode provocar a ocorrência do flag
enquanto não ocorrer o flag
faça instl ;
inst2;
........;
instN;
situação que pode provocar a ocorrência do flag;
Note que deveremos ter sempre uma ação que permita uma situação que pode
provocar a ocorrência do flag antes da estrutura, para que se tenha a possibilidade de
executar as instruções que compõe o bloco de instruções da estrutura, e dentro do bloco de
instruções da estrutura deveremos ter a mesma ação, devendo figurar como sendo a última
instrução do bloco.
Vejamos o seguinte exemplo (exemplo1):
Faça um algoritmo que some os números pertencentes a um conjunto. Neste
conjunto só existem números inteiros e positivos.
Note que não é dito no enunciado do problema que o número de elementos que o
compõe seja conhecido. Mas é dada uma restrição; os elementos nele contidos são inteiros
e positivos.
F
V
enquanto não flag
inst1;
inst2;
........;
instN;
flag;
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 85
Refinamento 1
- definir os objetos necessários;
- atribuir os valores iniciais;
- conhecer o primeiro número do conjunto;
- enquanto o número conhecido for válido, próximo número;
- informar o valor do somatório.
Refinamento 2
{objetos necessários}
num para representar os elementos do conjunto um a um;
soma para acumular os elementos válidos do conjunto.
{valores iniciais}
soma deve começar com o valor zero, por se tratar de um identificador somador.
{núcleo do processo de somatória}
leia (num); {conhecendo o primeiro valor do conjunto}
enquanto num for um elemento válido
faça acumule num em soma; leia(num); {conheça o próximo valor do conjunto}
escreva (soma);
Refinamento 3 (ver figura 7.4)
var num, soma : inteiro;
início {valores iniciais}
soma � 0;
leia (num); {conheça o 1°. número do conjunto}
enquanto num > 0 {enquanto for um número válido}
faça soma � soma + num; {acumule-o em soma}
leia (num); {conheça o próximo número do conjunto}
escreva (soma);
fim.
Observe que, num serve como flag para interrupção da estrutura iterativa. Como,
leia (num) é a única instrução que pode modificar o valor de num neste algoritmo, então
ela deve aparecer no algoritmo em duas situações. Uma antes da estrutura de iteração, para
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 86
garantir a possibilidade de execução das instruções que compõe a estrutura, e a outra, como
sendo a última instrução do bloco de instruções da estrutura, para garantir que os outros
elementos do conjunto tenham seus valores conhecidos e ter a possibilidade de fazer a
interrupção da execução.
Para interromper a execução da estrutura, em uma das instruções leia (num), temos
que fornecer um número menor ou igual a zero.
Se isto for feito na primeira instrução leia (num), então as instruções que compõe a
estrutura não serão executadas nenhuma vez, fazendo com que o valor associado ao
identificador soma seja zero, cujo valor lhe foi atribuído como valor inicial. Caso contrário,
isto poderá ser feito em qualquer instante, quando estivermos executando a instrução leia
(num) pertencente ao bloco de instruções da estrutura iterativa.
Figura 7.4 Fluxograma do exemplo1.
TESTE DE MESA (somatório de [5,8,3])
AÇÕES OBJETOS CONDIÇÃO
var num, soma : inteiro; num soma num>0
soma � 0; - 0 -
leia (num); 5 0 -
enquanto num > 0 faça 5 0 verdadeiro
soma � soma + num; 5 5 -
leia (num); 8 5 -
início
soma � 0;
soma � soma + num;
enquanto num > 0
escreva (soma);
fim.
leia (num);
leia (num);
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 87
enquanto num > 0 faça 8 5 verdadeiro
soma � soma + num; 8 13 -
leia (num); 3 13 -
enquanto num > 0 faça 3 13 verdadeiro
soma � soma + num; 3 16 -
leia (num); -1 16 -
enquanto num > 0 faça -1 16 falso
escreva (soma); - 16 -
7.5 - EXERCÍCIOS RESOLVIDOS
R.7.3 - Faça um algoritmo que calcule o somatório a seguir, até que um de seus termos
produza um valor inferior a 0,0005.
.......x5
5
x4
4
x3
3
x2
2
x1
1S −
+
+
+
−
+
+
+
−
+
=
para qualquer x > 0.
Solução:
Vejamos primeiro, o padrão de comportamento da série apresentada.
- Todos os termos possuem um numerador e um divisor (denominador);
- Os numeradores são constituídos apenas por constantes numéricas, não têm parte
literal;
- O numerador do primeiro termo é l. Para obter o numerador do segundo termo,
basta somar uma unidade no valor do primeiro. E para obter o terceiro, somamos
uma unidade no valor do segundo, e assim sucessivamente;
- O divisor (denominador) de cada termo é constituído de uma única parte literal,
somado com uma constante. O valor desta constante tem a mesma variação que o
numerador para cada termo;
- Entre termos existe uma alternância de sinal. O primeiro termo é positivo, o
segundo é negativo, ...e assim por diante;
- Para o cálculo do valor da série apresentada, é necessário ser conhecido,
previamente, o valor do identificador x.
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 88
Refinamento 1
- definir os objetos necessários á solução algorítmica do problema;
- atribuir valores iniciais necessários;
- conhecer o valor do argumento de entrada;
- calcular o valor da série apresentada;
- informar o resultado.
Refinamento 2
- objetos necessários
x é o argumento de entrada ao algoritmo;
s é o argumento de saída do algoritmo;
termo será usado no cálculo de cada termo da série;
sinal será usado para fazer a alternância de sinal entre os termos.Os únicos valores que
poderão ser atribuídos ao identificador sinal serão +1 e -1;
i representará o numerador de cada termo.
- valores iniciais
s : poderá ser inicializado com o valor zero, ou com o valor do primeiro termo da série.
sinal : como o primeiro termo da série é positivo, o valor de sinal será + l. i : o valor do numerador do primeiro termo é 1;
- conhecer o valor do argumento de entrada
leia (x);
- calcular o valor da série
- calcule o valor do primeiro termo;
- enquanto o valor do termo for superior a 0,0005
- faça - acumule o valor do termo, com sinal apropriado em s;
- troque o valor de sinal; - calcule o numerador do próximo termo;
- calcule o próximo termo;
- informar o resultado;
escreva (s);
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 89
Refinamento 3 (ver figura 7.5)
var i, sinal : inteiro;
x, s, termo : real;
início {valores iniciais}
s � 0;
sinal � 1;
i � 1;
leia (x);
termo � i / (i + x); {cálculo do 1°. termo}
enquanto termo > 0.0005 {cálculo dos próximos termos}
faça s � s + sinal * termo;
sinal � - sinal ; {alterando o valor de sinal}
i � i + l; {numerador do próximo termo}
termo � i / (i + x) ;
escreva (s);
fim.
Figura 7.5 Fluxograma do exercício resolvido R.7.3.
início
s � 0;
sinal � 1;
i � 1;
termo � i / (i + x);
s � s + sinal * termo;
sinal � -sinal;
i � i + 1;
termo � i / (i + x);
enquanto termo >
0.0005
escreva (s);
fim.
leia (x);
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 90
R.7.4 - Foi feita uma pesquisa na universidade entre os acadêmicos devidamente
matriculados na instituição. Todos os acadêmicos que estavam presentes no dia da pesquisa
preencheram o seguinte questionário:
Sexo? (M - Masculino, F - Feminino):
Idade? (em anos):
Gosta do curso que está fazendo? (S - Sim, N - Não):
O número de pessoas que responderam ao questionário é indeterminado. Faça um
algoritmo que seja capaz de fazer os seguintes cálculos:
a) o número de homens entrevistados;
b) o número de mulheres entrevistadas;
c) o percentual de mulheres entre todos os entrevistados;
d) quantos homens com menos de 23 anos não gostam do curso que estão fazendo.
Solução:
Refinamento 1
- definir objetos necessários;
- atribuir os valores iniciais;
- conhecer os dados de cada ficha de entrevista e para cada ficha verificar se foi
respondida por um homem ou por uma mulher. Se for homem conte mais uma
pessoa do sexo masculino, e verifique a sua idade, se for inferior a 23 anos então,
verifique a sua resposta se gosta ou não do curso. Se ele não gostar do curso; conte
mais um homem que não gosta do curso;
- faça os cálculos finais;
- informar os resultados.
Refinamento 2
- objetos necessários
Sexo : representará o sexo de cada um dos indivíduos entrevistados;
Idade: representará a idade de cada um dos entrevistados;
Resp : representará a resposta, se gosta ou não do curso, de cada um dos entrevistados;
ContaM: terá a função de contar o número de pessoas do sexo masculino que foram
entrevistados;
ContaF: terá a função de armazenar o número de pessoas do sexo feminino que foram
entrevistadas;
Perc: terá a função de armazenar o cálculo do percentual de pessoas do sexo feminino que
foram entrevistadas;
ContaI: terá a função de contar quantos homens com menos de 23 anos estão insatisfeitos
com o curso.
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 91
OBS.: {Sexo e Resp são definidos do tipo caractere pelo motivo de receberem como dados
as letras M ou F (Sexo), S ou N (Resp)}
- valores iniciais
Todos os objetos contadores deverão começar com o valor zero.
- Conhecer dados das fichas, fazer as verificações e contagens
leia dados da primeira ficha;
enquanto houver ficha para ser processada
faça se a ficha foi respondida por uma mulher
então conte mais uma pessoa do sexo feminino;
senão conte mais uma pessoa do sexo masculino;
se sua idade for inferior a 23 anos
então, se não gosta do seu curso
então conte mais um homem com menos de 23 anos
insatisfeito com o curso;
leia os dados da próxima ficha;
Um problema é saber determinar se há ou não mais fichas para serem processadas.
Podemos utilizar um flag para saber se a última ficha já foi processada ou não.
Para a escolha do flag podemos utilizar um dos identificadores do conjunto de
argumentos de entrada do algoritmo, como por exemplo, o identificador Sexo.
Sabemos que o identificador Sexo somente pode assumir os valores F ou M, logo
qualquer outro valor que seja atribuído a este identificador não terá uma conotação válida e,
portanto, podendo servir como forma de interrupção da estrutura de repetição.
- cálculos finais
- calcule o percentual de mulheres entre os entrevistados.
100 X Homens de Total Mulheres de Total
Mulheres de Totalmulheres %
+
=
- informar os resultados
escreva (ContaM, ContaF, Perc, ContaI);
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 92
Refinamento 3 (ver figura 7.6)
var ContaM, ContaF, ContaI, Idade : inteiro;
Perc : real;
Sexo, Resp : caractere;
início
{valores iniciais}
ContaM � 0;
ContaF � 0;
ContaI � 0;
leia (Sexo, Idade, Resp); {conheça os dados da 1ª. Ficha}
enquanto (Sexo = 'M') ou (Sexo = 'F')
faça se Sexo = 'F' {se a ficha foi respondida por uma mulher}
então ContaF � ContaF + 1 {mais uma mulher}
senão {só pode ser homem}
ContaM � ContaM + l;
se Idade < 23 {com menos de 23 anos}
então se Resp = 'N' {insatisfeito com o curso}
então ContaI � ContaI + 1;
leia (Sexo, Idade, Resp); {conheça os dados da próxima ficha}
Perc � ContaF / (ContaF + ContaM) * 100;
escreva (ContaF, ContaM, Perc, ContaI);
fim.
7.6 - QUEBRA DE NÍVEL
Existem muitos problemas que para serem resolvidos de forma satisfatória,
necessitam do aninhamento de estruturas iterativas.
O fato de uma estrutura iterativa estar dentro de outra estrutura, dizemos que o
algoritmo que as contém é quebrado em nível. Para haver a quebra de nível, necessita-se
ter, pelo menos, duas estruturas iterativas aninhadas.
enquanto condição1
faça ....
enquanto condição2
faça ....
....
....
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 93
Figura 7.6 Fluxograma do exercício resolvido R.7.4.
início
ContaM � 0;
ContaF � 0;
ContaI � 0;
ContaM � ContaM + 1;
enquanto Sexo=’F’ ou
Sexo=’M’
escreva (ContaF, ContaM, Perc, ContaI);
fim.
leia (Sexo, Idade, Resp);
se Sexo = ’F’
ContaF � ContaF + 1;
se Idade < 23
se Resp = ’N’
ContaI � ContaI + 1;
leia (Sexo, Idade, Resp);
Perc � ContaF / (ContaF + ContaM) * 100;
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 94
7.7 - EXERCÍCIOS RESOLVIDOS
R.7.5 - Dado um conjunto contendo dez números inteiros positivos, faça um algoritmo que
calcule o fatorial de cada um deles.
Solução: Refinamento 1
- definir os objetos necessários;
- atribuir valores iniciais;
- conhecer cada um dos valores do conjunto, e para cada valor conhecido calcular o
seu fatorial, informando o resultado obtido.
Refinamento 2
- objetos necessários
variação será de l a 10 de uma em uma unidade;
num : para representar um a um, os números pertencentes ao conjunto de valores dados;
fat : para representar o cálculo do fatorial de cada valor do conjunto de dados;
cont : contador de iterações para conhecimento dos valores do conjunto de dados. Como
existem 10 valores no conjunto, sua faixa de i : será usado como objeto auxiliar no cálculo
do fatorial de um número qualquer.
- valores iniciais
Como no conjunto existem 10 valores, os quais precisam ter seus valores
conhecidos, um a um, precisamos de um contador que nos indique qual a posição (1ª., 2ª.,
...) do número no conjunto que deverá ter seu fatorial calculado. Isto, para evitar que algum
número seja esquecido, ou que seja solicitado uma maior quantidade de números do que
aquela existente no conjunto.
Sabendo que no conjunto existem 10 números, e quem irá controlar a posição do
número que será conhecido para o cálculo do fatorial é o identificador cont, podemos fazer
com que seu valor inicial seja 1, indicando que será manipulado o primeiro número do
conjunto. O valor final de cont será 10 e sua variação será de uma unidade (1).
- conhecer os valores do conjunto, calcular os fatoriais e informar os resultados.
- enquanto não forem conhecidos os 10 valores do conjunto,
- conheça um valor de dado;
- calcule o seu fatorial;
- informe o resultado do fatorial calculado.
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 95
Refinamento 3
ae(num); {Conjunto de números inteiros e positivos}
as(fat); {Conjunto de valores de fatoriais}
objetos num, fat, cont, i : inteiro;
início cont � 1;
enquanto cont <= 10
faça - conhecer um valor de dado do conjunto;
- calcule o fatorial do valor conhecido;
- informe o valor do fatorial calculado;
- cont � cont + l; {aponte para o próximo número}
fim.
Refinamento 4
ae(num); {Conjunto de números inteiros e positivos}
as(fat); {Conjunto de valores de fatoriais}
objetos num, fat, cont, i : inteiro;
início cont �1;
enquanto cont <= 10
faça - leia (num);
{calcule o fatorial de num}
- atribua os valores iniciais para o cálculo do fatorial;
- calcule o fatorial de num e atribua o resultado ao identificador fat; - escreva (fat);
- cont � cont + 1; {aponte para o próximo número}
fim.
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 96
Refinamento 5
var num, fat, cont, i : inteiro;
início cont � 1;
enquanto cont <= 10
faça leia (num); {valores iniciais para o cálculo do fatorial}
i � 1;
fat � 1;
enquanto i <= num
faça fat � fat * i;
i � i + 1;
escreva (fat);
cont � cont + 1; {aponte para o próximo número}
fim.
R.7.6 - Uma determinada empresa, em fase de organização, deseja fazer um levantamento
do montante gasto com a folha de pagamento.
O resultado deste levantamento deverá conter os seguintes dados:
- Qual o total da folha de pagamento entre todos os funcionários da empresa?
- Qual o total da folha de pagamento em cada setor da empresa?
- Qual o valor do salário do funcionário melhor remunerado de cada setor?
Faça um algoritmo que seja capaz de fazer estes levantamentos, sabendo que os
dados estão organizados da seguinte forma:
- Cada setor possui um número inteiro positivo para a sua identificação;
- Todos os salários, individuais, dos funcionários estão separados por setor;
- Para cada setor existe uma planilha contendo: o número da identificação do setor, e os
ganhos salariais de cada um dos funcionários que o compõe.
Solução:
Refinamento 1
- definir os objetos necessários;
- atribuir valores iniciais;
- conhecer para cada setor, o salário de cada funcionário, acumular o salário de cada
funcionário no total gasto pelo setor, verificar qual o maior salário deste setor.
Acumular o total gasto por setor no total gasto pela empresa. Informe os resultados
obtidos.
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 97
Refinamento 2
- objetos necessários
Setor : para representar um a um, os setores da empresa. Como não é mencionado o total
de setores existentes na empresa, adotaremos o seguinte critério: o setor número zero não
existe, e a especificação deste valor indicará que não existem mais setores a serem
processados, ou que todos os setores já foram processados, ou que todos os setores já foram
processados, e portanto este setor (zero) deve ser desconsiderado;
Sal : para representar o salário de cada funcionário da empresa. Como, também, não
existem informações sobre o número de funcionários existentes em cada setor, adotaremos
o critério de que o valor do salário zero é de um funcionário inexistente, e portanto não
deverá ser considerado, mas este valor (zero) de salário servirá para indicar que ou não
existem funcionários lotados naquele setor, ou todos os salários dos funcionários
pertencentes ao mesmo já foram processados;
TotSet : representará o acumulador de salários para cada setor da empresa;
Maraja : representara o valor do maior salário de cada setor da empresa;
TotEmp : representará o acumulador de salários gasto em cada setor.
- Valores iniciais
Existem duas situações para atribuição de valores iniciais, uma quando estamos
tratando da empresa como um todo, no caso o montante gasto pela empresa na sua folha de
pagamento, e a outra quando estivermos tratando dos setores da empresa, no caso o
montante gasto por setor em salário mais alto de cada setor. No caso dos dois acumuladores
de salários, por se tratarem de totalizadores (TotSet, TotEmp), seus valores iniciais devem
ser zero (lembre-se, o zero é um elemento neutro na adição e subtração). E o representante
do maior salário de cada setor (Maraja), pelas restrições do problema (não existe salário
inferior ou igual a zero) deverá ser inicializado com o valor zero, pois certamente existe
alguém em cada setor que ganha mais do que isto.
- Ações
- atribuir valores iniciais;
- conhecer o número identificação da cada setor da empresa;
- para cada setor conhecido e enquanto houver setor não computado, conheça o salário de
cada funcionário integrante deste setor;
- para cada salário válido conhecido, acumule-o em TotSet, e verifique se o mesmo é o
maior salário até este momento para este setor;
- acumule o total de salários de cada setor em TotEmp (total de salários pago pela empresa;
- informar os resultados já obtidos.
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 98
Refinamento 3
ae(Setor, Sal); {Conjunto de setores, conjunto de salários}
as(TotSet, Maraja, TotEmp);
{Conjunto de salários acumulados, conjunto de maiores salários, total gasto pela empresa}
objetos Setor : inteiro;
Sal, TotEmp, TotSet, Maraja : real;
início TotEmp � 0;
conheça identificação do setor que será processado
enquanto o setor for válido
faça conheça o salário de cada funcionário do setor e, para cada salário
válido conhecido acumule-o em TotSet verificando também, se este
é o maior salário, até o momento, para este setor;
acumule o total de salários de cada setor em TotEmp (total de
salários pago pela empresa;
informe o total gasto neste setor;
informe o maior salário deste setor;
conheça a identificação do próximo setor;
informar o total gasto pela empresa;
fim.
Refinamento 4
ae(Setor, Sal); {Conjunto de setores, conjunto de salários}
as(TotSet, Maraja, TotEmp);
{Conjunto de salários acumulados, conjunto de maiores salários, total gasto pela empresa}
objetos Setor : inteiro;
Sal, TotEmp, TotSet, Maraja : real;
início TotEmp � 0;
leia (Setor);
enquanto Setor > 0 {enquanto houver setor válido}
faça conheça o salário de cada funcionário do setor e, para cada salário
válido conhecido acumule-o em TotSet verificando também, se este
é o maior salário, até o momento, para este setor;
TotEmp � TotEmp + TotSet;
escreva (TotSet);
escreva (Maraja);
leia (Setor);
escreva (TotEmp);
fim.
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 99
Refinamento 5
Dentro de cada setor existem funcionários, dos quais temos que conhecer os salários
para podermos totalizar o montante gasto em salários em cada setor e também, podemos
verificar qual o valor do salário mais alto de cada setor.
Para conhecermos o total de salários de cada setor utilizaremos o identificador
somador TotSet. Como se trata de um somador, seu valor inicial deve ser zero. Mas note
que, este valor inicial deve ser atribuído à TotSet toda vez que formos processar um novo
setor. E o mesmo acontece com o identificador Maraja, mesmo não se tratando de um
somador, ele terá a função de armazenar o maior salário do setor, processados até um
determinado instante. Assim, necessitamos de um valor inicial para servir como parâmetro
de comparação. Assim teremos:
ae(Setor, Sal); {Conjunto de setores, conjunto de salários}
as(TotSet, Maraja, TotEmp);
{Conjunto de salários acumulados, conjunto de maiores salários, total gasto pela empresa}
objetos
Setor : inteiro;
Sal, TotEmp, TotSet, Maraja : real;
início TotEmp � 0;
leia (Setor);
enquanto Setor > 0 {enquanto houver setor válido}
faça - atribuir valores iniciais, necessários ao processamento dos dados de
cada setor;
leia (Sal); {conhecendo o salário do 1º. Funcionário do setor}
enquanto o salário for válido
faça - acumule este salário conhecido no total gasto por este setor
em TotSet; - verifique se este salário é o maior até o momento, se for
atribua-o ao identificador Maraja;
- conheça o próximo salário deste setor;
TotEmp � TotEmp + TotSet;
escreva (TotSet);
escreva (Maraja);
leia (Setor);
escreva (TotEmp);
fim.
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 100
Refinamento 6
ae(Setor, Sal); {Conjunto de setores, conjunto de salários}
as(TotSet, Maraja, TotEmp);
{Conjunto de salários acumulados, conjunto de maiores salários, total gasto pela empresa}
objetos
Setor : inteiro;
Sal, TotEmp, TotSet, Maraja : real;
início
TotEmp � 0;
leia (Setor);
enquanto Setor > 0 {enquanto houver setor válido}
faça TotSet � 0;
marajá � 0; {alguém receberá mais do que isto. Este valor serve
como base para a 1ª. Comparação}
leia (Sal); {conhecendo o salário do l°. funcionário do setor}
enquanto Sal > 0
faça TotSet � TotSet + sal;
se Sal > Maraja {existe alguém que recebe mais que o
Maraja atual}
então Maraja � Sal; {Temos um novo Maraja}
conheça(sal);
TotEmp � TotEmp + TotSet;
escreva (TotSet);
escreva (Maraja);
leia (Setor);
escreva (TotEmp);
fim.
7.8 - OUTRAS ESTRUTURAS DE CONTROLE DE CICLOS
Além da estrutura enquanto faça ainda existem mais duas estruturas que podem ser
usadas no controle de ciclos. A estrutura repita até e a estrutura para até passo faça.
7.8.1 - REPITA ATÉ
A estrutura repita até é muito parecida com a estrutura enquanto faça, por ter a
interrupção da execução das ações controladas por uma condição. A sua sintaxe:
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 101
repita
inst1;
inst2;
……;
instN;
até condição;
onde: repita até � é a instrução de controle de ciclo;
inst1; ...; instN � são as instruções que compõe o bloco de instruções que
podem ser executadas várias vezes;
condição � pode ser uma expressão relacional, ou uma expressão lógica, ou
um identificador lógico.
As diferenças entre as duas estruturas são:
• A estrutura enquanto faça tem interrupção do ciclo no início, enquanto a estrutura
repita até em interrupção do ciclo no fim. Isto quer dizer que na estrutura repita até o
bloco de instruções é executado pelo menos uma vez, para depois ser avaliado o valor
de condição. Na estrutura enquanto faça o número mínimo de vezes que um ciclo pode
ser executado é zero;
• A forma de interrupção do ciclo é diferente nas duas estruturas. Na estrutura enquanto faça o ciclo é repetido enquanto a condição avaliada fornecer o valor verdadeiro. Na
estrutura repita até o ciclo será repetido até que a condição avaliada forneça o valor
verdadeiro, ou seja, o valor falso de condição indica a ação de repitibilidade do bloco de
instruções.
O bloco de instruções deve ser executado pelo menos
repita uma vez, independente do valor avaliado em condição.
inst1;
inst2;
......;
FALSO
instN;
VERDADEIRO
até condição;
instX;
7.8.2 - EXERCÍCIO RESOLVIDO
R.7.7 - Dado um número n inteiro, faça um algoritmo que seja capaz de informar o valor 0
(zero) se o mesmo for primo, ou 1 (um) se não for primo.
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 102
Solução:
Por definição, todo o número primo só pode ser dividido por 1 e por ele mesmo.
Logo, para verificar se um número é primo ou não, basta dividí-lo por um conjunto de
números entre 2 e n - 1. Se neste intervalo houver algum valor que é divisor de n, então ele
não é primo, caso contrário o será.
Com esta definição, podemos fazer algumas simplificações matemáticas, para evitar
operações desnecessárias.
- Qualquer número n, só pode ser dividido, em uma divisão inteira por um número
que seja igual ou inferior á sua metade;
- Os números inteiros positivos inferiores ou igual a 3 são primos. Assim:
var n, meio, resto, divisor, res : inteiro;
NãoPrimo : lógico;
{n - representa o número que se quer saber se é primo, ou não;
meio - guardará a metade inteiro de n;
resto - para verificar se n é divisível por divisor;
divisor - guardará um valor entre 2 e a metade de n, e será utilizado como
divisor de n;
res - guardará o resultado final do problema 0, ou 1;
NãoPrimo - será utilizado como auxiliar, para descobrir se um determinado
número é primo ou não. Os seus valores possíveis são verdadeiro, indicando
que o número não é primo, ou falso, indicando que o número é primo}
início leia (n);
NãoPrimo � falso; {assumindo que n é primo}
se n > 3
então divisor � 2;
meio � 2/n ;
repita resto � n - divisor * divisor/n ;
se resto = 0
então NãoPrimo � verdadeiro
senão NãoPrimo � falso;
divisor � divisor + l;
até NãoPrimo ou ( divisor > meio);
se NãoPrimo
então res � 1
senão res � 0;
escreva (res); fim.
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 103
7.8.3 - PARA ATÉ PASSO FAÇA
A estrutura para até passo faça, difere das outras duas por ser controlada por um
contador, e não por condição, como já foi visto. A sintaxe geral desta instrução é:
para vc � vi até vf passo vp
faça inst1;
inst2;
........;
instN;
onde:
para até passo faça � é a estrutura de controle de ciclo, controlado por contador;
vc � é a variável de controle;
vi � representa o valor inicial de vc;
vf � representa o valor final de vc;
vp � representa o valor do passo com que vc deve ser incrementado a cada iteração;
inst1; ...; instN � compõe o bloco de instruções que poderá ser executado várias vezes.
A semântica de funcionamento desta instrução será ilustrada no exemplo a seguir.
.......
para i � até 5 passo 2
faça inst1;
inst2;
........;
instN;
.......
Quando iniciarmos a execução desta instrução, a variável de controle i recebe o
valor inicial 1. Se este valor for inferior ou igual ao valor final, no caso 5, então o bloco de
instruções é executado uma vez. Ao terminar a execução do bloco, a variável de controle i deve ter o seu valor atual incrementado com o valor do passo, 2, e este resultado, passa a
ser o valor atual da variável de controle, i ���� i + vp, ou seja, i ���� 1 + 2. Se este valor
continuar sendo inferior ou igual ao valor final, então o bloco de instruções deve ser
executado mais uma vez, e ao término da execução, a variável de controle deve ser
incrementada com o valor do passo, repetindo a verificação da condição i <= vf. Quando a condição i <= vf não se verificar mais, a repetição da execução do bloco
de instruções é encerrado, e o controle de execução deve ser passado para a primeira
instrução que vier após esta estrutura.
CAPÍTULO 7 – ESTRUTURAS DE CONTROLE DE ITERAÇÕES 104
Esta estrutura deve ser aplicada somente nos casos em que se conhece o número de
vezes que o bloco de instruções vai ser repetido.
O valor do passo é incrementado automaticamente na variável de controle ao fim de
cada iteração.
7.8.4 - EXERCÍCIO RESOLVIDO
R.7.8 - Calcular o fatorial de um número inteiro positivo.
Solução:
var n, fat, i : inteiro;
início leia (n);
fat � 1;
para i � l até n passo 2
faça fat � fat * i;
escreva (fat);
fim.
Top Related