CAPÍTULO 7 - ESTRUTURAS DE CONTROLE DE ITERAÇÕES

Transcrição

1 CAPÍTULO 7 - ESTRUTURAS DE CONTROLE DE ITERAÇÕES 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) 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.

2 CAPÍTULO 7 ESTRUTURAS DE CONTROLE DE ITERAÇÕES 75 var num1, num2, num3, num4, num5, soma : inteiro; leia (num1, num2, num3, num4, num5); soma num1 + num2 + num3 + num4 + num5; escreva (soma); Esta é uma solução trivial do problema dado. Note que se expandíssemos o limite superior de 5 para 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; soma 0; i 1; soma soma + i; {não foi somado ninguém ainda} {i começa representando o 1. valor do intervalo} {atribua a soma o valor associado a ela somado com o valor associado a i} {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} {gere o próximo valor de i} {as próximas ações são idênticas} soma soma + i; soma soma + i; soma soma + i; escreva (soma); 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.

3 CAPÍTULO 7 ESTRUTURAS DE CONTROLE DE ITERAÇÕES 76 soma 0; i 1; soma soma + 1; soma soma + 1; soma soma + 1; soma soma + 1; soma soma + 1; soma soma + 1; escreva (soma); 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;

4 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 inst1; inst2; inst3; ; instn; enquanto condição inst1; inst2;...; instn; onde: enquanto é 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. V F enquanto condição instx; inst1; inst2; inst3;...; instn; falso verdadeiro Fluxo a ser seguido quando o valor da condição for verdadeiro. Fluxo a ser seguido quando o valor da condição for falso.

5 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; soma 0; i l ; enquanto i <= 5 soma soma + i; escreva (soma); soma 0; i 1; enquanto i <= 5 soma soma + 1; escreva (soma); Fazendo um teste de mesa: AÇÕES OBJETOS CONDIÇÃO var soma, i : inteiro; soma i i <= 5 * soma 0; i 1; enquanto i <= verdadeiro soma soma + i; enquanto i <= verdadeiro soma soma + i; enquanto i <= verdadeiro soma soma + i; enquanto i <= verdadeiro soma soma + i; enquanto i <= verdadeiro soma soma + i;

6 CAPÍTULO 7 ESTRUTURAS DE CONTROLE DE ITERAÇÕES 79 enquanto i <= falso escreva (soma); * 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 , basta apenas trocar a relação i <= 5 para i <= 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} leia (n); soma 0; i 1; enquanto i <= n soma soma + 1; {acumule em soma o valor de i} i i +1; {incremente uma unidade no valor de i} escreva (soma); 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 EXERCÍCIOS RESOLVIDOS R Sendo conhecido um conjunto com 10 números inteiros, 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.

7 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 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} {valores iniciais} soma 0; i 1; enquanto i <= 10 leia(num); {conheça um número do conjunto} soma soma + num; {acumule-o em soma} {incremente uma unidade em i} escreva (soma); Faça um teste de mesa neste algoritmo para os valores [2, 5, 3, 0, -4, 4, 8, 9, 19, 22].

8 CAPÍTULO 7 ESTRUTURAS DE CONTROLE DE ITERAÇÕES 81 soma 0; i 1; enquanto i <= 10 leia (num); soma soma + num; escreva (soma); Figura 7.2 Fluxograma do exercício resolvido R.7.1. R 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. e por definição 0! = 1, 1! = 1. n! = 1 * 2 * 3 *... * (n - 1) * (n)

9 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} {valores iniciais} fat 1; i 1; leia (n); enquanto i <= n {para todo i entre 1 e n} fat fat * i; {multiplique o valor de fat com o valor de i, armazene o resultado em fat} escreva (fat);

10 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; i 1; leia(n); enquanto i <= n verdadeiro fat fat * i; enquanto i <= n verdadeiro fat fat * i; enquanto i <= n verdadeiro fat fat * i; enquanto i <= n falso escreva (fat); fat 1; i 1; leia (n); enquanto i <= n fat fat * i; escreva (fat); Figura 7.3 Fluxograma do exercício resolvido R.7.2.

11 CAPÍTULO 7 ESTRUTURAS DE CONTROLE DE ITERAÇÕES 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 instl ; inst2;...; instn; situação que pode provocar a ocorrência do flag; enquanto não flag inst1; inst2;...; instn; flag; V F 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.

12 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 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; {valores iniciais} soma 0; leia (num); {conheça o 1. número do conjunto} enquanto num > 0 {enquanto for um número válido} soma soma + num; {acumule-o em soma} leia (num); {conheça o próximo número do conjunto} escreva (soma); 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

13 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. soma 0; leia (num); enquanto num > 0 soma soma + num; leia (num); escreva (soma); 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; leia (num); enquanto num > verdadeiro soma soma + num; leia (num); 8 5 -

14 CAPÍTULO 7 ESTRUTURAS DE CONTROLE DE ITERAÇÕES 87 enquanto num > verdadeiro soma soma + num; leia (num); enquanto num > verdadeiro soma soma + num; leia (num); enquanto num > falso escreva (soma); EXERCÍCIOS RESOLVIDOS R Faça um algoritmo que calcule o somatório a seguir, até que um de seus termos produza um valor inferior a 0, S = x 2 + x 3 + x 4 + x 5 + x 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.

15 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, 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);

16 CAPÍTULO 7 ESTRUTURAS DE CONTROLE DE ITERAÇÕES 89 Refinamento 3 (ver figura 7.5) var i, sinal : inteiro; x, s, termo : real; {valores iniciais} s 0; sinal 1; i 1; leia (x); termo i / (i + x); enquanto termo > s s + sinal * termo; sinal - sinal ; i i + l; termo i / (i + x) ; escreva (s); {cálculo do 1. termo} {cálculo dos próximos termos} {alterando o valor de sinal} {numerador do próximo termo} s 0; sinal 1; i 1; leia (x); termo i / (i + x); enquanto termo > s s + sinal * termo; sinal -sinal; termo i / (i + x); escreva (s); Figura 7.5 Fluxograma do exercício resolvido R.7.3.

17 CAPÍTULO 7 ESTRUTURAS DE CONTROLE DE ITERAÇÕES 90 R 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; - 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.

18 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 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. % mulheres = Total de Mulheres Total de Mulheres X100 + Total de Homens - informar os resultados escreva (ContaM, ContaF, Perc, ContaI);

19 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; {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') 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); 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... enquanto condição

20 CAPÍTULO 7 ESTRUTURAS DE CONTROLE DE ITERAÇÕES 93 ContaM 0; ContaF 0; ContaI 0; leia (Sexo, Idade, Resp); enquanto Sexo= F ou Sexo= M se Sexo = F ContaF ContaF + 1; ContaM ContaM + 1; se Idade < 23 se Resp = N ContaI ContaI + 1; leia (Sexo, Idade, Resp); Perc ContaF / (ContaF + ContaM) * 100; escreva (ContaF, ContaM, Perc, ContaI); Figura 7.6 Fluxograma do exercício resolvido R.7.4.

21 CAPÍTULO 7 ESTRUTURAS DE CONTROLE DE ITERAÇÕES EXERCÍCIOS RESOLVIDOS R Dado um conjunto contendo dez números inteiros positivos, 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.

22 CAPÍTULO 7 ESTRUTURAS DE CONTROLE DE ITERAÇÕES 95 Refinamento 3 ae(num); as(fat); {Conjunto de números inteiros e positivos} {Conjunto de valores de fatoriais} objetos num, fat, cont, i : inteiro; cont 1; enquanto cont <= 10 - 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} Refinamento 4 ae(num); as(fat); {Conjunto de números inteiros e positivos} {Conjunto de valores de fatoriais} objetos num, fat, cont, i : inteiro; cont 1; enquanto cont <= 10 - 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}

23 CAPÍTULO 7 ESTRUTURAS DE CONTROLE DE ITERAÇÕES 96 Refinamento 5 var num, fat, cont, i : inteiro; cont 1; enquanto cont <= 10 leia (num); {valores iniciais para o cálculo do fatorial} i 1; fat 1; enquanto i <= num fat fat * i; escreva (fat); cont cont + 1; {aponte para o próximo número} R 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.

24 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.

25 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; TotEmp 0; conheça identificação do setor que será processado enquanto o setor for válido 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; 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; TotEmp 0; leia (Setor); enquanto Setor > 0 {enquanto houver setor válido} 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);

26 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; TotEmp 0; leia (Setor); enquanto Setor > 0 {enquanto houver setor válido} - 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 - 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);

27 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; TotEmp 0; leia (Setor); enquanto Setor > 0 {enquanto houver setor válido} 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 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); OUTRAS ESTRUTURAS DE CONTROLE DE CICLOS Além da estrutura enquanto ainda existem mais duas estruturas que podem ser usadas no controle de ciclos. A estrutura repita até e a estrutura para até passo REPITA ATÉ A estrutura repita até é muito parecida com a estrutura enquanto, por ter a interrupção da execução das ações controladas por uma condição. A sua sintaxe:

28 CAPÍTULO 7 ESTRUTURAS DE CONTROLE DE ITERAÇÕES 101 repita até condição; inst1; inst2; ; instn; 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 tem interrupção do ciclo no, enquanto a estrutura repita até em interrupção do ciclo no 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 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 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. repita O bloco de instruções deve ser executado pelo menos uma vez, independente do valor avaliado em condição. inst1; inst2;...; instn; até condição; FALSO VERDADEIRO instx; EXERCÍCIO RESOLVIDO R Dado um número n inteiro, um algoritmo que seja capaz de informar o valor 0 (zero) se o mesmo for primo, ou 1 (um) se não for primo.

29 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} leia (n); NãoPrimo falso; {assumindo que n é primo} se n > 3 então divisor 2; meio n / 2 ; repita resto n - divisor * n / divisor ; 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);

30 CAPÍTULO 7 ESTRUTURAS DE CONTROLE DE ITERAÇÕES PARA ATÉ PASSO FAÇA A estrutura para até passo, 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 inst1; inst2;...; instn; onde: para até passo é 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 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 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.

31 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 EXERCÍCIO RESOLVIDO R Calcular o fatorial de um número inteiro positivo. Solução: var n, fat, i : inteiro; leia (n); fat 1; para i l até n passo 2 fat fat * i; escreva (fat);