CAPÍTULO 7 - din.uem.bryandre/fundamentos_producao/EST_ITE.pdf · - Usaremos o identificador i para gerar os números entre 1 e n para serem usados no produtório; {atribuir valores

$Page 1: CAPÍTULO 7 - din.uem.bryandre/fundamentos_producao/EST_ITE.pdf · - Usaremos o identificador i para gerar os números entre 1 e n para serem usados no produtório; {atribuir valores$
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.


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;


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.


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 -



i � i + 1; 3 3 -



i � i + 1; 6 4 -


soma � soma + i; 10 4 -

i � i + 1; 10 5 -


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.


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.


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


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.




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


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;



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}



{informe o valor do fatorial} escreva (fat);


var n, fat, i : inteiro; {n representa o valor para cálculo do fatorial}

{fat representa o valor do fatorial de n}


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.


TESTE DE MESA (Cálculo de 3 ! )


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 -


fat � fat * i; - 2 2 -

i � i + 1; - 2 3 -


fat � fat * i; - 6 3 -

i � i + 1; - 6 4 -

enquanto i <= n faça - 6 4 falso

escreva (fat); - 6 - -


início

fat � 1;

i � 1;

fat � fat * i;

i � i + 1;

enquanto i <= n

escreva (fat);

fim.

leia (n);


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;


Refinamento 1


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


var num, soma : inteiro;


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


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])


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




leia (num); 3 13 -



leia (num); -1 16 -

enquanto num > 0 faça -1 16 falso

escreva (soma); - 16 -


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.


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



var i, sinal : inteiro;

x, s, termo : real;


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.


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


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


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.


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



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

....

....



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;



R.7.5 - Dado um conjunto contendo dez números inteiros positivos, faça um algoritmo que

calcule o fatorial de cada um deles.




- conhecer cada um dos valores do conjunto, e para cada valor conhecido calcular o

seu fatorial, informando o resultado obtido.

Refinamento 2


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.


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.


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



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


Refinamento 2


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


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


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




objetos Setor : inteiro;



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.


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:




objetos

Setor : inteiro;



leia (Setor);


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;


escreva (TotSet);

escreva (Maraja);

leia (Setor);

escreva (TotEmp);

fim.


Refinamento 6




objetos

Setor : inteiro;


início

TotEmp � 0;

leia (Setor);


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


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:


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.


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.


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.


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.

Documents

CAPÍTULO 7 - din.uem.bryandre/fundamentos_producao/EST_ITE.pdf · - Usaremos o identificador i para gerar os números entre 1 e n para serem usados no produtório; {atribuir valores