View
2.457
Download
1
Category
Preview:
Citation preview
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 autoincrementá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çãoUma 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: realinicio 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: realinicio 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 – FIMPARA2) ENQUANTO FACA FIMENQUANTO3) 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> FACAComando 1Comando 2Comando 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: inteiroinicio palavra < "escrevame 20 vezes" para cont < 1 ate 20 faca escreval(palavra) fimparafimalgoritmo
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: inteiroinicio palavra < "a vez" para cont < 1 ate 20 faca escreval(cont, palavra) fimparafimalgoritmo
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: inteiroinicio 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) fimparafimalgoritmo
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: inteiroinicio 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) fimparafimalgoritmo
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: inteiroinicio para cont < 20 ate 1 passo 1 faca escreval(cont) fimparafimalgoritmo
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 nFIMENQUANTO
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 voltase 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:
linha1linha2linha3linha4linha5linha6linha7linha8linha9linha10linha11
algoritmo "exemplo"var nome: caractereinicio nome < "comeco" enquanto nome <> "fim" faca escreval("digite o nome") leia(nome) escreval("o nome digitado foi ", nome) fimenquantofimalgoritmo
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:
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
algoritmo "exemplo"var cont, idade, soma: inteiroinicio soma < 0 para cont < 1 ate 10 faca escreva("digite a idade") leia(idade) soma < soma + idade fimpara escreva("soma das idades = ", soma)fimalgoritmo
seja, o contador deve ser sempre menor ou no máximo igual a 10. Além disso, é importante ressaltar que diferentemente da estrutura PARA FACAFIMPARA, 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:
linha1linha2linha3linha4linha5linha6linha7linha8linha9linha10linha11linha12linha13linha14
algoritmo "exemplo"var cont, idade, soma: inteiroinicio 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: inteiroinicio 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"Var a, s: inteiroInicio a < 1 s < 0 enquanto (a < 5) faca s < s + a a < a + 2 escreval(a, s) fimenquantoFimalgoritmo
Algoritmo "questao2b"Var a, n, s: inteiroInicio a < 1 n < 0 s < 0 enquanto (s < 5) faca s < s + a a < a + 1 n < n + 1 escreval(s, a, n) fimenquantoFimalgoritmo
Algoritmo "questao2c"Var a, n, s: inteiroInicio a < 2 n < 3 s < 1 enquanto (s < 5) faca s < s + 1 a < a + s n < n + a escreval(s, a, n) fimenquantoFimalgoritmo
3) Responda quais os resultados dos seguintes algoritmos:
a) b)algoritmo "questao3a"var aux, x, y, t, w: inteiroinicio 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
algoritmo "questao3b"var x, w: inteiroinicio 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: inteiroinicio 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 <= 5001 100 100 VERDADEIRO2 100 200 VERDADEIRO3 120 320 VERDADEIRO4 120 440 VERDADEIRO5 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 3045 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 nATE <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.
Baseandose 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: caracterinicio 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"var soma, idade: inteiroinicio soma < 0 repita escreva("digite a idade ") leia(idade) soma < soma + idade escreval(soma) ate (soma > 500) ou (idade > 100)fimalgoritmoConsidere que o usuário irá digitar como entrada os seguintes valores de idades:Utilização 1: 40,98,101,23,55Utilização 2: 99,48,66,100,78,55,64, 89,34,68,9,12,29,57
algoritmo "questao1b"var a, b, c: inteiro flag: logicoinicio flag < falso a < 20 b < 10 c < 5 repita a < b + c c < b b < a escreval(a," ", b, " ",c) se (a + b + c) > 200 entao flag < verdadeiro fimse ate flagfimalgoritmo
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:
S=11−
32
53−
74. ..−
9950
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 caracterizase 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 . . .
Recommended