CAPÍTULO 6 ­ ESTRUTURAS DE REPETIÇÃO

Objetivos da aula (previsão 8h/aula)
1. (   )  Identificar a necessidade de utilizar uma estrutura de repetição para a resolução  de um determinado problema. 2. (   )  Diferenciar as diferentes estruturas de repetição existentes a aplicabilidade de  cada estrutura para os diversos tipos de problemas 3. (   )  Saber utilizar a estrutura de repetição PARA FAÇA cujo controle é realizado por  um contador auto­incrementável 4. (   )  Saber utilizar as estruturas de repetição ENQUANTO FAÇA e REPITA ATÉ  cujo controle é realizado pelo usuário. 5. (   ) Identificar a necessidade de utilizar e saber resolver problemas que necessitem de  estruturas de repetição dentro de outras estruturas de repetição. (1)Totalmente Alcançado (2)Parcialmente Alcançado (3)Não Alcançado

    6 Estruturas de Repetição
Uma das principais características que consolidaram o sucesso na utilização dos  computadores para a resolução de problemas foi a sua capacidade de repetir o  processamento de um conjunto de operações para grandes quantidades de dados. Exemplos  de conjuntos de tarefas que repetimos diversas vezes dentro de uma situação específica  podem ser observados largamente no nosso dia a dia.  Por exemplo, consideremos que uma determinada loja de calçados efetue uma venda no  crediário para um cliente que ainda não está registrado em seu sistema. Para realizar essa  venda,   é   necessário   cadastrar   o   cliente,   solicitando   informações   básicas   como:   nome,  endereço, CPF, RG, lojas do comércio onde já possui crédito, etc. Essas etapas para realizar  o cadastro seguirão sempre a mesma ordem para cada novo cliente que aparecer na loja.  Caso precisássemos desenvolver um sistema para efetuar os cadastros de clientes de uma  loja,   não  haveria   lógica  que  programássemos   novamente  essas  etapas  para  cada   cliente  novo, bastaria que desenvolvêssemos uma única vez a seqüência de etapas e que a cada  novo cliente usássemos a seqüência previamente definida. Outro exemplo que podemos observar é o cálculo das médias dos alunos de uma turma  qualquer. Para calcular a média de um único aluno é necessário que somemos suas duas  notas e dividamos o resultado dessa soma por dois. Um algoritmo simples para o cálculo da  média de um aluno seria:
algoritmo "calculo_media" var   n1, n2, media: real inicio   escreval("digite nota 1 e nota 2")   leia(n1, n2)   media <­ (n1 + n2)/2   escreval("a media do aluno é ", media) fimalgoritmo

Bom, se desejássemos calcular as médias de dois alunos poderíamos simplesmente copiar  as mesmas linhas de código e colá­las no mesmo programa para o cálculo da média do  segundo aluno:
algoritmo "calculo_media" var   n1, n2, media: real inicio   escreval("digite nota 1 e nota 2")   leia(n1, n2)   media <­ (n1 + n2)/2   escreval("a media do aluno é ", media)   escreval("digite nota 1 e nota 2")   leia(n1, n2)   media <­ (n1 + n2)/2   escreval("a media do aluno é ", media) fimalgoritmo

Entretanto, se considerarmos que uma turma possui 50 alunos ficaria um pouco complicado  repetir essas mesmas linhas 50 vezes.  Para a resolução desse tipo de problema utilizamos as ESTRUTURAS DE REPETIÇÃO.  As 3 ESTRUTURAS DE REPETIÇÃO que iremos estudar são: 1) PARA FACA – FIMPARA 2) ENQUANTO FACA ­ FIMENQUANTO 3) REPITA ­ ATE 6.1 Estrutura de Repetição PARA FACA ­ FIMPARA A estrutura de repetição PARA FACA ­ FIMPARA é utilizada sempre que temos condições  de   estabelecer   a   QUANTIDADE   de   vezes   que   uma   determinada   seqüência   de  operações deve ser executada. Por exemplo, na situação de cálculo de médias dos alunos,  sabemos que o número de alunos da turma é de 50 (mesmo não conhecendo esse valor de  antemão, temos condições de solicitá­lo ao usuário). Dessa maneira podemos definir com  exatidão o número de vezes que precisaremos calcular a média dos alunos. A estrutura de repetição PARA FACA ­ FIMPARA é utilizada da seguinte maneira:
PARA <variavel inteira> <­ <valor inicial> ATE  <valor final>  FACA Comando 1 Comando 2 Comando N  FIMPARA

Onde a <variável inteira> será um contador que marcará em qual iteração a estrutura de  repetição   se   encontra.   O   <valor   inicial>   é   o   valor   em   que   o   contador   irá   começar   a  contagem, e a o <valor final> é o valor onde o contador irá  parar a execução. A cada  iteração o contador (<variável inteira>) será incrementado (aumentado) em 1, e quando esse  contador atingir o mesmo valor que o <valor final> a estrutura de repetição chega ao final.  Por exemplo, caso desejemos escrever 20 vezes uma frase na tela, utilizaríamos a estrutura  de repetição PARA FACA – FIMPARA, iniciando um contador em 1 e indicando que a  repetição deve acontecer até que esse contador chegue ao número 20. Veja o exemplo a  seguir:

algoritmo "imprime_palavra" var   palavra: caractere   cont: inteiro inicio   palavra <­ "escreva­me 20 vezes"   para cont <­ 1 ate 20 faca     escreval(palavra)   fimpara fimalgoritmo

A execução do algoritmo anterior traria como resultado uma tela semelhante a que está  sendo mostrada a seguir:

Como comentado anteriormente, a variável que representa o contador é incrementada em  cada iteração (no exemplo anterior a variável cont representa o contador). Dessa forma, na  1a iteração ela possui o valor 1, na 2a iteração o valor 2, e assim sucessivamente até que ela  chegue ao valor 20. Observe o exemplo a seguir:
algoritmo "imprime_palavra" var   palavra: caractere   cont: inteiro inicio   palavra <­ "a vez"   para cont <­ 1 ate 20 faca     escreval(cont, palavra)   fimpara fimalgoritmo

O   código   mostrado   anteriormente   apresentaria   a   seguinte   tela   como   resultado   de   sua  execução:

Conhecendo os detalhes de utilização dessa estrutura podemos tentar solucionar o problema  do cálculo da média dos 50  alunos de uma turma. O primeiro passo é definir como seria o  processamento para um único aluno, considerando que necessitamos solicitar as duas notas  e calcular a média dessas notas, teríamos o seguinte processamento:
  escreval("digite nota 1 e nota 2 do aluno 1")   leia(n1, n2)   media <­ (n1 + n2)/2   escreval("a media do aluno é ", media)

Para que esse trecho de código seja executado 50 vezes, é necessário que utilizemos alguma  estrutura   de   repetição.   Nesse   caso   utilizaremos   a   estrutura   PARA   FACA   –   FIMPARA.  Necessitamos de uma variável que assuma o papel de contador, e devemos fazer com que  essa variável comece com o valor 1 e   termine   com   o   valor  50.   Vejamos   o   algoritmo   a  seguir:

algoritmo "imprime_palavra" var   n1, n2,media: real   cont: inteiro inicio   para cont <­ 1 ate 50 faca     escreval("digite nota 1 e nota 2 do aluno ", cont)     leia(n1, n2)     media <­ (n1 + n2)/2     escreval("a media do aluno é", media)   fimpara fimalgoritmo

Os valores  do inicio e do final da iteração podem também ser  definidos em tempo de  execução   por   meio   de   variáveis.   Por   exemplo,   considere   que   a   princípio   não   sabemos  quantos   são   os   alunos   de   uma   turma.   Dessa   maneira,   podemos   solicitar   ao   usuário   o  número de alunos (nalunos), e utilizar essa variável como o valor de limite para a iteração.  Comparando com o algoritmo anterior, ao invés de utilizarmos o valor 50 utilizaremos uma  variável que contenha o número de alunos da turma (nalunos). Veja o trecho de código a  seguir:
algoritmo "imprime_palavra" var   n1, n2,media: real   nalunos, cont: inteiro inicio   escreval("digite o numero de alunos da turma")   leia(nalunos)   para cont <­ 1 ate nalunos faca     escreval("digite nota 1 e nota 2 do aluno ", cont)     leia(n1, n2)     media <­ (n1 + n2)/2     escreval("a media do aluno é", media)   fimpara fimalgoritmo

Veja o exemplo de tela para o resultado de execução do algoritmo anterior:

Os   exemplos   vistos   anteriormente   utilizam   uma   ordem   crescente   para   incrementar   o  contador, ou seja, a iteração varia de um número menor até alcançar um número maior.  Também é possível que façamos de traz para frente, ou em ordem decrescente. Por exemplo,  suponha   que   desejamos   escrever   os   números   de   20   até   1.   Para   esse   tipo   de   problema  podemos utilizar a estrutura de repetição PARA FACA especificando que o PASSO para o  algoritmo é decrescente, ou melhor, ­1. Veja o exemplo a seguir:
algoritmo "imprime_palavra" var   cont: inteiro inicio   para cont <­ 20 ate 1 passo ­1 faca     escreval(cont)   fimpara fimalgoritmo

O resultado do algoritmo anterior seria apresentado da seguinte forma:

  6.2 Exercícios ESTRUTURA DE REPETIÇÃO PARA FACA ­ FIMPARA 6.2.1 Exercícios utilizando somente a estrutura de repetição PARA FACA ­ FIMPARA 1) Elabore um algoritmo que imprima todos os números de 1 até 100. 2) Elabore um algoritmo que imprima todos os números de 100 até 1. 3) Elabore um algoritmo que imprima todos os números de 250 a 500. 4) Elabore um algoritmo que leia um número de entrada que indicará a quantidade de  números a serem lidos. Em seguida, leia  n  números (conforme o valor informado  anteriormente) e imprima o triplo de cada um. 6.2.2   Exercícios   utilizando   a   estrutura   de   condição   SE   ENTAO   FIMSE   dentro   da  estrutura de repetição PARA FACA ­ FIMPARA 1) Elabore um algoritmo que leia nome, idade e sexo de 20 pessoas. Imprimir o nome,  se a pessoa for do sexo masculino, e tiver mais de 21 anos. 2) Elabore um algoritmo que imprima todos os números pares de 1 até 100.

6.2.3 Exercícios de repetição que calculam somatórios e/ou produtos   1) Elabore um algoritmo que imprima todos os números de 100 a 200, e ao final a  soma deles. 2) Elabore um algoritmo que leia um número e imprima todos os números de 1 até o  número lido, e também o seu produto. Exemplo: Número: 3 Saída: 1 2 3  Produto: 6

3) Construir um algoritmo que calcule o fatorial de um número.  4) Construir um algoritmo que leia dois números (BASE e EXPOENTE) e retorne  como resultado a POTENCIA do cálculo da BASE elevado ao EXPOENTE.  Ex: para a  BASE = 2 e EXPOENTE = 4,    POTENCIA = 24 = 16 5) Elabore um algoritmo que imprima a tabuada de um número que será informado  pelo usuário.

6) Elabore um algoritmo que leia 30 números, e imprima quantos números maiores que  30 foram digitados.

6.2.4 Exercícios de repetição que calculam somatórios e/ou produtos e que utilizam a  estrutura de condição  SE ENTAO FIMSE dentro da estrutura de repetição  PARA  FACA ­ FIMPARA 1) Elabore um algoritmo que leia um número e imprima a soma dos números múltiplos  de 5 no intervalo entre 1 e o número informado. Suponha que o número lido será  maior que zero. 2) Elabore um algoritmo que leia 20 números, e ao final, imprima a média desses  números. 3) Elabore um algoritmo que leia 200 números, e imprima quantos são pares e quantos  são ímpares. 6.2.5   Exercícios   de   repetição   para   localizar   determinados   valores   dentro   de   um  conjunto 1) Elabore um algoritmo que leia um número de entrada que indicará a quantidade de  números a serem lidos. Em seguida, leia  n  números (conforme o valor informado  anteriormente) e, ao final imprima o maior número digitado. 2) Elabore um algoritmo que leia um número de entrada que indicará a quantidade de  números a serem lidos. Em seguida, leia  n  números (conforme o valor informado  anteriormente) e, ao final imprima o menor número digitado. 3) Elabore um algoritmo que leia um número de entrada que indicará a quantidade de  números a serem lidos. Em seguida, leia  n  números (conforme o valor informado  anteriormente)   e,   ao   final   imprima   o   maior,   menor,   e   a   média   dos   números  digitados. 6.2.6   Exercício   utilizando   a   estrutura   de   repetição   PARA   FACA   –   FIMPARA  aninhada.  1) Elabore um algoritmo que imprima a tabuada de 1 a 10. 6.2.7 Implemente os algoritmos anteriores no VISUALG e no TURBO PASCAL.

6.3 Demais Estruturas de Repetição  Quando   não   temos   condições   de   precisar   quantas   vezes   um   determinado   conjunto   de  comandos precisa ser executado devemos utilizar as Estruturas de Repetição ENQUANTO  FACA ­ FIMENQUANTO ou REPITA ­ ATE.  6.3.1 Estrutura de Repetição ENQUANTO FACA ­ FIMENQUANTO Vamos observar de maneira mais clara uma situação onde não conseguimos determinar a  quantidade de vezes que executaremos um conjunto de comandos. Por exemplo, suponha  que estamos oferecendo ao usuário 3 opções de menu sendo que uma dessas 3 opções seria  a opção de SAIR do programa. Caso desejemos que o usuário possa executar várias vezes  as opções dispostas no menu, não temos como adivinhar quando o usuário irá optar por  SAIR do algoritmo, sendo assim, não podemos limitar a repetição a um número de vezes. Considere um problema mais específico onde necessitamos fazer a leitura de vários nomes  de pessoas e a cada nome que é lido devemos escrever na tela a frase "O nome digitado foi  NOME". A princípio isso deve ser feito inúmeras vezes e quando o usuário digitar um  NOME igual a FIM o algoritmo deve parar. Da mesma maneira que no exemplo anterior  não   podemos   definir   quando   o   usuário   irá   digitar   FIM,   e   não   temos   como   precisar   a  quantidade de vezes que o algoritmo deverá repetir esse conjunto de ações.  Nessas situações, a repetição de um conjunto de comandos é determinada pela avaliação de  uma expressão lógica, ou seja, caso o valor da expressão lógica seja verdadeiro o conjunto  de   comandos   continua   a   ser   executado,   caso   o   valor   da   expressão   lógica   seja   falso   a  estrutura de repetição é abortada. A estrutura de repetição ENQUANTO FACA ­ FIMENQUANTO é utilizada da seguinte  maneira:
ENQUANTO <EXPRESSÃO LÓGICA> FACA   comando 1   comando 2       .      .      .    comando n FIMENQUANTO

Antes de entrar na estrutura de repetição, a expressão lógica é avaliada, caso o resultado da  mesma seja VERDADEIRO os comandos que estão dentro da estrutura serão executados e  ao final volta­se a avaliar a expressão lógica novamente. Caso o resultado da expressão  lógica seja falso, o algoritmo sai da estrutura de repetição. 

Avalie a execução do seguinte algoritmo:
linha1 linha2 linha3 linha4 linha5 linha6 linha7 linha8 linha9 linha10 linha11 algoritmo "exemplo" var   nome: caractere inicio   nome <­ "comeco"   enquanto nome <> "fim" faca     escreval("digite o nome")     leia(nome)     escreval("o nome digitado foi ", nome)   fimenquanto fimalgoritmo

Ao chegar na linha5 o algoritmo irá inicializar a variável NOME com o valor “comeco”. Na  linha6 temos o início da estrutura de repetição sendo que a expressão lógica que está sendo  avaliada é NOME <> "fim", ou seja, está sendo avaliado se o conteúdo da variável NOME é  diferente da palavra "fim". Caso o conteúdo de NOME seja diferente de "fim", o resultado  da expressão lógica será VERDADEIRO e os comandos que estão dentro da estrutura de  repetição   serão   executados.   No   nosso   exemplo,   o   valor   da   variável   NOME   é   igual   a  “começo”, então ao avaliar se NOME <> "fim", teremos que "comeco" <> "fim" é igual a  VERDADEIRO, e então os comandos das linhas 7, 8 e 9 serão executados. Enfim, após essa primeira avaliação, e considerando que o NOME era "comeco" (que é  diferente de "fim"), o algoritmo irá executar a linha7 e pedir para o usuário digitar um  nome, e em seguida irá ler esse nome (linha8) e escrever o mesmo na tela (linha9). Ao  chegar no final da estrutura de repetição (linha10), o algoritmo irá retornar ao início dessa  estrutura para avaliar novamente a expressão lógica NOME <> "fim" (linha6). Faça o teste de mesa do algoritmo anterior para as seguintes entradas do usuário:
interação 1 2 3 4 NOME "comeco" "joão" "pedro" "maria" "fim"

O que será escrito na tela para o usuário? A seguir é mostrada a tela de resultado para a  execução do algoritmo apresentado 

Apesar   da   estrutura   de   repetição   ENQUANTO   FACA   ­   FIMENQUANTO   ser   utilizada  especialmente para quando não podemos determinar o número de vezes que o conjunto de  comandos será repetido, nada impede que utilizemos uma expressão lógica que avalie o  valor de um número, simulando dessa forma uma estrutura de repetição PARA FACA ­  FIMPARA. Suponha que desejemos realizar um conjunto de operações 10 vezes, como por exemplo,  pedir a idade de 10 pessoas e calcular a soma dessas 10 idades.  Utilizando   a   estrutura   de   repetição  PARA   FACA   ­   FIM   PARA  teríamos   o   seguinte  algoritmo:
algoritmo "exemplo" var  cont, idade, soma: inteiro inicio   soma <­ 0   para cont <­ 1 ate 10 faca     escreva("digite a idade")     leia(idade)     soma <­ soma + idade   fimpara   escreva("soma das idades = ", soma) fimalgoritmo

Caso   desejássemos   escrever   esse   mesmo   algoritmo   utilizando   a   estrutura   de   repetição  ENQUANTO   FACA   –   FIMENQUANTO,   teríamos   que   nos   preocupar   em   avaliar   uma  expressão lógica que garanta que o contador chegue ao número máximo de 10 vezes, ou 

seja, o contador deve ser sempre menor ou no máximo igual a 10. Além disso, é importante  ressaltar que diferentemente da estrutura PARA FACA­FIMPARA, a estrutura de repetição  ENQUANTO FACA ­ FIMENQUANTO deve se preocupar em incrementar o seu contador,  ou seja, a cada iteração devemos fazer com que o contador aumente o seu valor em um. Veja o algoritmo a seguir:
linha1 linha2 linha3 linha4 linha5 linha6 linha7 linha8 linha9 linha10 linha11 linha12 linha13 linha14 algoritmo "exemplo" var  cont, idade, soma: inteiro inicio   soma <­ 0   cont <­ 1   enquanto cont <= 10 faca     escreval("digite a idade")     leia(idade)     soma <­ soma + idade     cont <­ cont + 1   fimenquanto   escreva("soma das idades = ", soma) fimalgoritmo

Note que na linha6 é necessário que inicializemos o contador  cont  com o valor  1. E na  linha11,  a variável  cont  deve ser  incrementada, ou seja, aumentada em  1.  Pensando  na  execução do algoritmo anterior, veremos que a cada iteração, a variável cont é testada na  linha7 e enquanto a mesma tiver um valor menor ou igual a 10 (valores 1, 2,3, 4, 5, 6, 7, 8,  9,10) o algoritmo irá executar as linhas 8, 9, 10 e 11. Assim que o contador (variável cont)  atingir o  valor 11 a expressão lógica  cont <= 10 será considerada falsa e o algoritmo irá  pular para a linha13. Mas   afinal,   qual   seria   a   vantagem   de   utilizarmos   a   estrutura   ENQUANTO   FACA   ­  FIMENQUANTO para esse tipo de situação, considerando que já possuímos a estrutura de  repetição PARA FACA ­ FIMPARA ? A   vantagem   está   no   fato   da   estrutura   de   repetição   ENQUANTO   FACA   ­   FIMENQUANTO nos permitir utilizar expressões lógicas compostas, ou seja, podemos   trabalhar com contadores ao mesmo tempo em que avaliamos outras variáveis do nosso   algoritmo. Suponhamos que necessitamos realizar um algoritmo semelhante ao do exemplo anterior,  porém agora além de limitarmos o número máximo de pessoas em 10, queremos também  limitar a soma das idades dessas pessoas. Por exemplo, o algoritmo deve solicitar as idades  das pessoas enquanto o número de pessoas não chegar a 10, e também enquanto a soma de  idade   dessas   pessoas   não   ultrapassar   100   anos.   Caso   uma   dessas   condições   não   seja  obedecida   a   estrutura   de   repetição   deverá   ser   abortada.   Vejamos   como   ficaria   esse  algoritmo:

algoritmo "exemplo" var   cont, idade, soma: inteiro inicio   soma <­ 0   cont <­ 1   enquanto (cont <= 10) e (soma < 100) faca     escreval("digite a idade")     leia(idade)     soma <­ soma + idade     cont <­ cont + 1   fimenquanto   escreval("numero de pessoas" , cont ­ 1)   escreva("soma das idades = ", soma) fimalgoritmo

6.3.2   Exercícios   ESTRUTURA   DE   REPETIÇÃO   ENQUANTO   FACA   ­  FIMENQUANTO 1) Elabore um algoritmo que imprima os números de 1 até 100. 2) Faça o teste de mesa para os conjuntos de instruções abaixo: a)
Algoritmo "questao2a" Var    a, s: inteiro Inicio   a <­ 1   s <­ 0   enquanto (a < 5) faca     s <­ s + a     a <­ a + 2     escreval(a, s)   fimenquanto Fimalgoritmo

b)
Algoritmo "questao2b" Var    a, n, s: inteiro Inicio    a <­ 1    n <­ 0    s  <­ 0    enquanto (s < 5) faca      s <­ s + a      a <­ a + 1      n <­ n + 1      escreval(s, a, n)    fimenquanto Fimalgoritmo

c)
Algoritmo "questao2c" Var    a, n, s: inteiro Inicio    a <­  2    n <­ 3    s <­ 1    enquanto (s < 5) faca      s <­ s + 1      a <­ a + s      n <­ n + a      escreval(s, a, n)    fimenquanto Fimalgoritmo

 

3) Responda quais os resultados dos seguintes algoritmos:
a)  algoritmo "questao3a" var   aux, x, y, t, w: inteiro inicio   x <­ 2   y <­ 5   t <­ 15   w <­ 1   x <­ (x * 4) mod 5   y <­ y * w   se (x > 2) e (y=5) entao     aux <­  y     y <­ t     t <­ aux   senao     y <­ t     t <­ y   fimse   escreva(x, y, t) Fimalgoritmo b) algoritmo "questao3b" var   x, w: inteiro inicio   x <­ 2   w <­ 1   enquanto x = 2 faca     se nao (x > 2) entao       x <­ (x * 2) ­ (w +1)     senao       x <­ 3     fimse     escreva(x, w)   fimenquanto fimalgoritmo

4) Elabore um algoritmo que entre com números e imprima o triplo de cada um. O  algoritmo acaba quando entrar o número –999 (incluindo o último número). 5) Elabore um algoritmo que entre com números enquanto forem positivos e imprimir  quantos números que foram digitados (incluindo o último número). 6) Elabore um algoritmo que entre com números enquanto forem positivos e imprima  ao final a soma dos números que foram digitados (incluindo o último número). 7) Elabore um algoritmo que entre com vários números positivos e imprima ao final a  média dos números digitados (incluindo o último número). 8) Elabore   um   algoritmo   que   leia   nomes   enquanto   forem   diferentes   de   FIM,  imprimindo o nome logo após a leitura (incluindo o nome  “fim”). 9) Elabore um algoritmo que solicite ao usuário quantidade de números que ele irá  digitar, leia esses vários números e imprima o maior, o menor e a média aritmética  dos números. 10) Construir   um   algoritmo   que   solicite   ao   usuário   o   número   de   pessoas   de   uma  determinada família, a idade em anos de cada uma das pessoas, e que calcule a  média de idade da família (correspondendo a soma de todas as idades divididas pelo  número de pessoas). 

6.3.3 Exercícios comentados

Sabemos   que  um  determinado elevador   tem espaço para no  máximo  7 pessoas  e  pode  suportar transportar até 500 kg. Como você desenvolveria um algoritmo para permitir a  entrada de pessoas nos elevadores considerando essas condições e utilizando a estrutura de  repetição ENQUANTO FACA ­ FIMENQUANTO?
algoritmo "exemplo" var   cont, peso, pesototal: inteiro inicio   pesototal <­ 0   cont <­ 1   enquanto (cont <= 10) e (pesototal <= 500) faca     escreval("peso do proximo a subir no elevador")     leia(peso)     pesototal <­ pesototal + peso     cont <­ cont + 1   fimenquanto   escreval("numero de pessoas que subiram" , cont ­ 1)   escreva("peso total do elevador = ", pesototal) fimalgoritmo

A   solução   anterior   apresenta   um   problema,   você   consegue   identificar   qual   seria   esse  problema? O problema existente é que mesmo depois de realizar a verificação do pesototal,  é possível que a soma do pesototal com o próximo peso exceda 500 quilos. Isso acontece  pois dentro da estrutura de repetição o pesototal é somado com o valor do peso que foi  recentemente lido, e o resultado dessa soma somente é  verificado para a realização da  próxima   iteração.   Por   exemplo,   considere   a   execução   do   algoritmo   para   os   seguintes  valores: cont 1 2 3 4 5 Peso 100 100 120 120 120 Pesototal 100 200 320 440 560 Pesototal <= 500 VERDADEIRO VERDADEIRO VERDADEIRO VERDADEIRO VERDADEIRO

Ao chegar na 4a iteração, quando o contador cont está com o valor 4, o peso lido será de 120  quilos e o pesototal será de 440. Ao sair dessa iteração, o algoritmo irá avaliar se o pesototal  é menor ou igual a 500, e o resultado será verdadeiro. Entrando novamente na estrutura de  repetição e indo para a 5a iteração, o peso lido será de 120 quilos e o pesototal irá para 560  quilos,   excedendo   o   limite   do   elevador.   Veja   um   exemplo   de   tela   para   a   execução   do  algoritmo anterior:

  Uma  alternativa para resolver  o  problema do  algoritmo anterior  seria  fazer  a  avaliação  antecipada da soma do pesototal  e do peso da próxima pessoa que iria entrar no elevador.  Veja a solução a seguir:
   algoritmo "exemplo"    var      cont, peso, pesototal: inteiro    inicio      pesototal <­ 0      cont <­ 1      escreval("peso do proximo a subir no elevador")      leia(peso)      enquanto (cont <= 10) e (pesototal + peso <= 500) faca        pesototal <­ pesototal + peso        cont <­ cont + 1        escreval("peso do proximo a subir no elevador")        leia(peso)      fimenquanto      escreval("numero de pessoas que subiram" , cont ­ 1)      escreva("peso total do elevador = ", pesototal)    fimalgoritmo

6.3.4   Exercícios   ESTRUTURA   DE   REPETIÇÃO   ENQUANTO   FACA   –  FIMENQUANTO 1) Elabore um algoritmo que leia a idade e sexo (0 – masculino, 1 – feminino) de várias  pessoas (solicite ao usuário o número de pessoas). Calcule e imprima a idade média,  total de pessoas do sexo feminino com idade entre 30­45 anos inclusive, e o número  total de pessoas do sexo masculino. O algoritmo termina quando se digita 0 para a  idade.

2) Elabore um algoritmo que leia a idade e o estado civil (c – casado, s – solteiro, v –  viúvo, e d – desquitado ou separado) de várias pessoas. Considere que o algoritmo  termina quando se digita um número menor do que 0 para a idade. Ao final, calcule e  imprima: a. A quantidade de pessoas casadas; b. A quantidade de pessoas solteiras; c. A média das idades das pessoas viúvas; d. A porcentagem de pessoas desquitadas ou separadas, dentre todas as pessoas  analisadas.

6.3.5 Estrutura de Repetição REPITA ­ ATE A   estrutura   de   repetição   REPITA   ­   ATE   funciona   de   forma   semelhante   a   estrutura   de  repetição ENQUANTO FACA – FIMENQUANTO, porém diferem em um aspecto muito  importante, na estrutura de repetição ENQUANTO FACA – FIMENQUANTO a avaliação  da   expressão   lógica   é   realizada   ANTES   de   executar   os   comandos,   e   na   estrutura   de  repetição REPITA ­ ATE a expressão lógica é avaliada somente DEPOIS de executar os  comandos. Veja como se utiliza a estrutura de repetição REPITA ATE:
REPITA    comando 1   comando 2       .      .      .   comando n ATE <EXPRESSAO LÓGICA>

Dessa   forma   o  algoritmo   entra   na   estrutura,   executa   os   comandos   que  estão   dentro   da  mesma   e   ao   final   verifica   a   validade   da   expressão   lógica,   caso   a   mesma   tenha   como  resultado VERDADEIRO a repetição é abortada, caso o resultado da expressão lógica seja  FALSO a repetição continua até que a expressão seja VERDADEIRA. Baseando­se   nessa   diferença   entre   as   estruturas,   podemos   afirmar   que   um   conjunto   de  comandos   que   estão   dentro   de   uma   estrutura   de   repetição   REPITA   ATE   serão   sempre  executados   no   mínimo   uma   vez,   enquanto   que   na   estrutura   de   repetição   ENQUANTO  FAÇA   –   FIMENQUANTO   existe   a   possibilidade   dos   comandos   que   estão   dentro   da  estrutura não serem executados nenhuma vez. Suponha que desejemos desenvolver um algoritmo que solicite o nome de pessoas inúmeras  vezes e que escreva o nome que foi digitado. O algoritmo deve fazer isso até o momento em  que o usuário digitar um nome igual a FIM. Utilizando a estrutura de repetição REPITA  ATE, a solução poderia ser desenvolvida da seguinte maneira:
algoritmo "exercicio" var   nome: caracter inicio   repita     escreval("digite o nome")     leia(nome)     escreval("o nome digitado foi ", nome)   ate nome = "fim" fimalgoritmo

Uma tela de execução para o algoritmo anterior é mostrada logo a seguir:

6.3.6 Exercícios ESTRUTURA DE REPETIÇÃO REPITA ­ATE

1) Faça o teste de mesa para os algoritmos a seguir:
a)  b) algoritmo "questao1a" algoritmo "questao1b" var var   soma, idade: inteiro   a, b, c: inteiro inicio   flag: logico   soma <­ 0 inicio   repita   flag <­ falso     escreva("digite a idade ")   a <­ 20     leia(idade)   b <­ 10     soma <­ soma + idade   c <­ 5     escreval(soma)   repita   ate (soma > 500) ou (idade > 100)     a <­ b + c fimalgoritmo     c <­ b Considere que o usuário irá digitar      b <­ a como entrada os seguintes valores de      escreval(a," ", b, " ",c)     se (a + b + c) > 200 entao idades:       flag <­ verdadeiro Utilização 1: 40,98,101,23,55 Utilização 2: 99,48,66,100,78,55,64,      fimse   ate flag 89,34,68,9,12,29,57 fimalgoritmo

2) Desenvolva os exercícios da lista 6.3.2 (exceto os exercícios de teste de mesa) e 6.3.4  utilizando a estrutura de repetição REPITA ATE.

6.4 Exercícios (Séries) 1) Escrever um programa para calcular e imprimir o valor de S na expressão abaixo:
1 3 5 7 99 S = −  − . ..− 1 2 3 4 50

2) Elaborar um programa que utilize uma subrotina para calcular a serie de fibonacci de N  termos. A série de Fibonacci é formada pela sequência : 1, 2, 3, 5, 8, 13, 21, 34, ..., etc. Esta  série caracteriza­se pela soma de um termo posterior com o seu subsequente, e ela deve ser  impressa até que o último elemento não ultrapasse o valor de entrada N.  3) Construa um algoritmo que imprima a série abaixo, onde o número de termos da mesma  deve ser lido. Série  =  2, 7, 3, 4, 21, 12, 8, 63, 48, 16, 189, 192, 32, 567, 768, 64 . . .