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 algoritmo "exemplo"
linha2 var
linha3   nome: caractere
linha4 inicio
linha5   nome <­ "comeco"
linha6   enquanto nome <> "fim" faca
linha7     escreval("digite o nome")
linha8     leia(nome)
linha9     escreval("o nome digitado foi ", nome)
linha10   fimenquanto
linha11 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 NOME
"comeco"
1 "joão"
2 "pedro"
3 "maria"
4 "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 algoritmo "exemplo"
linha2 var
linha3  cont, idade, soma: inteiro
linha4 inicio
linha5   soma <­ 0
linha6   cont <­ 1
linha7   enquanto cont <= 10 faca
linha8     escreval("digite a idade")
linha9     leia(idade)
linha10     soma <­ soma + idade
linha11     cont <­ cont + 1
linha12   fimenquanto
linha13   escreva("soma das idades = ", soma)
linha14 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) b) c)
Algoritmo "questao2a" Algoritmo "questao2b" Algoritmo "questao2c"
Var Var Var
   a, s: inteiro    a, n, s: inteiro    a, n, s: inteiro
Inicio Inicio Inicio
  a <­ 1    a <­ 1    a <­  2
  s <­ 0    n <­ 0    n <­ 3
  enquanto (a < 5) faca    s  <­ 0    s <­ 1
    s <­ s + a    enquanto (s < 5) faca    enquanto (s < 5) faca
    a <­ a + 2      s <­ s + a      s <­ s + 1
    escreval(a, s)      a <­ a + 1      a <­ a + s
  fimenquanto      n <­ n + 1      n <­ n + a
Fimalgoritmo      escreval(s, a, n)      escreval(s, a, n)
   fimenquanto    fimenquanto
Fimalgoritmo Fimalgoritmo
 
3) Responda quais os resultados dos seguintes algoritmos:

a)  b)
algoritmo "questao3a" algoritmo "questao3b"
var var
  aux, x, y, t, w: inteiro   x, w: inteiro
inicio inicio
  x <­ 2   x <­ 2
  y <­ 5   w <­ 1
  t <­ 15   enquanto x = 2 faca
  w <­ 1     se nao (x > 2) entao
  x <­ (x * 4) mod 5       x <­ (x * 2) ­ (w +1)
  y <­ y * w     senao
  se (x > 2) e (y=5) entao       x <­ 3
    aux <­  y     fimse
    y <­ t     escreva(x, w)
    t <­ aux   fimenquanto
  senao
    y <­ t fimalgoritmo
    t <­ y
  fimse
  escreva(x, y, t)
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 Peso Pesototal Pesototal <= 500

1 100 100 VERDADEIRO
2 100 200 VERDADEIRO
3 120 320 VERDADEIRO
4 120 440 VERDADEIRO
5 120 560 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)
idades:     se (a + b + c) > 200 entao
Utilização 1: 40,98,101,23,55       flag <­ verdadeiro
Utilização 2: 99,48,66,100,78,55,64,      fimse
89,34,68,9,12,29,57   ate flag
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 . . .