Lógica e Linguagem de Programação Aula 04 - Estruturas de Repetição Repetição com Teste no Final - Repita Até - GABARITO Professor: Danilo Giacobo

Transcrição

1 Lógica e Linguagem de Programação Aula 04 - Estruturas de Repetição Repetição com Teste no Final - Repita Até - GABARITO Professor: Danilo Giacobo Este guia irá lhe ajudar a entender o laço de repetição -até. Ela é uma estrutura de repetição usada para repetir um ou mais comandos baseado em uma condição que é sempre testada no final da estrutura. Ele repete (executa) as instruções até que a condição se torne verdadeira. Enquanto ela for falsa este laço de repetição continua executando as instruções. Sua sintaxe, isto é, a forma de escrever corretamente o mesmo em pseudocódigo é: C1; C2; Cn; até <condição>; Onde: <condição> é uma expressão simples ou composta que resulte em verdadeiro ou falso; C1, C2, Cn são instruções válidas de um algoritmo em pseudocódigo. O funcionamento básico do laço -até se resume então a: Executar as instruções contidas dentro do laço de repetição na sequência em que foram escritas; Quando chegar ao final da estrutura (até <condição>) a condição é verificada. Se ela (a condição) for verdadeira, o laço de repetição é encerrado com apenas uma repetição. Ele sempre é executado ao menos uma vez! Se ela (a condição) for falsa, então os comandos dentro da estrutura serão executados novamente do início () e quando chegar ao último comando a condição é novamente testada para ver se continua a execução do laço ou não e assim até a condição ser verdadeira e o mesmo ser encerrado. Um cuidado muito importante a ser tomado é escrever o laço de repetição cuja condição possa se tornar verdadeira para que o algoritmo possa terminar sua execução; caso contrário acontecerá o que chamamos de laço infinito ou loop infinito, algo extremamente perigoso em um programa de computador real. Geralmente usamos uma variável do tipo contadora (uma variável simples do tipo inteiro) para sabermos quantas vezes o laço de repetição já executou, assim conseguimos controlar melhor a repetição das instruções contidas no mesmo. A seguir serão mostrados alguns exemplos simples de utilização do laço -até. Algumas partes do algoritmo serão omitidas por questões de espaço.

2 1. Escrever seu nome 5 (cinco) vezes. inteiro: contador; contador 1; escreva ( Danilo Giacobo ); contador contador + 1; até (contador > 5); 2. Escrever seu nome n vezes. inteiro: contador, n; contador 1; escreva ( Danilo Giacobo ); contador contador + 1; até (contador > n); 3. Escrever os números inteiros de 0 a 10. inteiro: contador; contador 0; escreva (contador); contador contador + 1; até (contador > 10); 4. Escrever os números pares entre 0 e 20. inteiro: contador; contador 0; escreva (contador); contador contador + 2; até (contador > 20); 5. Escrever os números ímpares entre 1 e Exibir uma contagem regressiva com BOOM inteiro: contador; contador 10; escreva (contador); contador contador - 1; até (contador < 0); escreva ( *** BOOOOOM *** ); 7. Realizar a soma dos números inteiros de 1 a 10. inteiro: n, soma; n 1; soma soma + n; n n + 1; até (n > 10); escreva (soma); 8. Realizar a soma em separado dos números pares e ímpares de 1 a 20. inteiro: n, soma_p, soma_i; n 1; soma_p 0; soma_i 0; se (n mod 2 = 0) então soma_p soma_p + n; senão soma_i soma_i + n; n n + 1; até (n > 20); escreva (soma_p, soma_i); inteiro: contador; contador 1; escreva (contador); contador contador + 2; até (contador > 30);

3 Usando a estrutura -até para validação de dados O -até é bastante útil em um algoritmo/programa para realizar a validação dos dados de entrada de um processo. Como ele verifica o dado depois de lido ele se torna a estrutura ideal para esse tipo de caso. A seguir são mostrados alguns exemplos. Para validar se um número é positivo. inteiro: n; até (n >= 0); Para validar se um número é maior que zero e emitir uma mensagem. inteiro: n; se (n <= 0) então escreva ( Informe um número maior que 0. ); até (n > 0); Para validar se uma nota é válida (considerando 0 a 100). real: nota; leia (nota); até (nota >= 0 e nota <= 100); Para validar se uma nota é válida (considerando 0 a 100) e mostrar uma mensagem. real: nota; leia (nota); se (nota < 0 ou nota > 100) então escreva ( Informe uma nota entre 0 e 100. ); até (nota >= 0 e nota <= 100); Para validar se um conceito é válido. caracter: conceito; leia (conceito); até (conceito = A ou conceito = B ou conceito = C ou conceito = D ); Para validar se um conceito é válido e emitir uma mensagem. caracter: conceito; leia (conceito); se (conceito <> A e conceito <> B e conceito <> C e conceito <> D ) então escreva ( Informe A, B, C ou D. ); até (conceito = A ou conceito = B ou conceito = C ou conceito = D ); Para validar o sexo de uma pessoa. caracter: sexo; leia (sexo); até (sexo = M ou sexo = F ); Para validar o sexo de uma pessoa e emitir uma mensagem. caracter: sexo; leia (sexo); se (sexo <> M e sexo <> F ) então escreva ( Informe M ou F. ); até (sexo = M ou sexo = F ); Para validar se uma variável do tipo inteiro qualquer possui um determinado valor e continuar repetindo até a pessoa informar esse valor. inteiro: var; leia (var); até (var = 0);

4 Usando a estrutura de repetição -até para repetir o algoritmo todo. A estrutura -até é útil para repetir grande parte do algoritmo depois que o mesmo é executado pela primeira vez. Nos exemplos abaixo ele é usado para pedir para a pessoa se ela quer executar o algoritmo mais uma vez; caso ela não queria a mesma deve informar o valor que encerra o algoritmo. Exemplo 1: algoritmo para verificar se um número é par. início inteiro: n; caracter: continuar; escreva ( Informe um número inteiro: ); se (n mod 2 = 0) então escreva ( O número informado é par! ); senão escreva ( O número informado não é par! ); escreva ( Deseja tentar novamente (S/N)? ); leia (continuar); até (continuar = N ); Exemplo 2: algoritmo para verificar se um número é primo. início inteiro: n, qtde, cont; caracter: continuar; qtde 0; enquanto (cont <= n) faça se (n mod cont = 0) então qtde qtde + 1; fimenquanto; se (qtde = 2) então escreva ( O número informado é primo! ); senão escreva ( O número informado não é primo! ); escreva ( Deseja tentar novamente (S/N)? ); leia (continuar); até (continuar = N );

5 Exercícios Resolva os problemas a seguir usando a estrutura de repetição -até. 1. Escrever um algoritmo para mostrar os números inteiros de 0 a 10 (crescente). inteiro: cont; cont 0; escreva (cont); até (cont > 10); // cont = Escrever um algoritmo para mostrar os números inteiros de 10 a 1 (decrescente). inteiro: cont; cont 10; escreva (cont); cont cont - 1; até (cont < 1); // cont = 0 3. Escrever um algoritmo para mostrar os números reais entre 0 e 5 (de meio em meio). real: cont; cont 0; escreva (cont); cont cont + 0,5; até (cont > 5);

6 4. Escrever um algoritmo para mostrar os números inteiros maiores que um número informado pela pessoa até chegar em inteiro: cont, n; cont n + 1; escreva (cont); até (cont > 1000); 5. Escrever um algoritmo para mostrar os números inteiros menores que um número informado pela pessoa até chegar em 0. inteiro: cont, n; cont n - 1; escreva (cont); cont cont - 1; até (cont < 0); 6. Escolha um algoritmo qualquer que você desenvolveu usando o enquanto e modifique o mesmo para usar a estrutura -até. O algoritmo escolhido pelo professor foi o da TABUADA. inteiro: n, cont, r; r n * cont; escreva (n, " * ", cont, " = ", r); até (cont > 10);

7 7. Escolha um algoritmo qualquer que você desenvolveu usando o enquanto e modifique o mesmo para realizar a validação da entrada de dados usando a estrutura -até. O algoritmo escolhido pelo professor foi o da TABUADA. A validação de dados realizada é a de deixar apenas números de 1 a 10 serem usados. inteiro: n, cont, r; se (n < 1 ou n > 10) então escreva ( Informe um número entre 1 e 10. ); até (n >= 1 e n <= 10); r n * cont; escreva (n, " * ", cont, " = ", r); até (cont > 10); 8. Escolha um algoritmo qualquer que você desenvolveu usando o enquanto e modifique o mesmo para que a pessoa possa usar o algoritmo mais de uma vez usando a estrutura até. O algoritmo escolhido pelo professor foi o da TABUADA. inteiro: n, cont, r; caracter: op; r n * cont; escreva (n, " * ", cont, " = ", r); até (cont > 10); escreva ( Deseja executar novamente [S/N]? ); leia (op); até (op = N );

8 9. Escreva um algoritmo para converter um número decimal em binário. inteiro: n, r, b; r n; b r mod 2; r r div 2; escreva (b); se (r = 1 ou r = 0) então escreva (r); até (r < 2); 10. Escreva um algoritmo para ler o nome de cinco pessoas e mostrar o nome das mesmas. inteiro: cont; caracter: nome; leia (nome); escreva (nome); até (cont > 5); 11. Escreva um algoritmo para realizar a soma de um conjunto de valores inteiros informados pela pessoa. Ela inicialmente entrará com o número de valores que ela deseja usar. inteiro: cont, n, valor, soma; leia (valor); soma soma + valor; até (cont > n); escreva (soma);

9 12. Escreva um algoritmo para apresentar a soma dos cem primeiros números naturais ( ). inteiro: n, soma; n 1; soma soma + n; n n + 1; até (n > 100); escreva (soma); 13. Escreva um algoritmo para gerar a tabuada de um número inteiro informado pela pessoa. Este número deverá ser maior que 0. Realize a validação de dados para isso. inteiro: n, cont, r; se (n <= 0) então escreva ( Informe um número maior que zero. ); até (n > 0); r n * cont; escreva (n, " * ", cont, " = ", r); até (cont > 10); 14. Elabore um algoritmo que apresente o somatório dos valores pares existentes na faixa de 1 até 500. inteiro: n, soma; n 2; soma soma + n; n n + 2; até (n > 500);

10 escreva (soma); 15. Elabore um algoritmo que apresente todos os valores numéricos inteiros ímpares situados na faixa de 0 a 20. inteiro: n; n 1; escreva (n); n n + 2; até (n > 20); 16. Elabore um algoritmo que apresente os valores numéricos divisíveis por 4 e menores que 200. Sugestão: a variável que controla o contador do laço deve ser iniciada com valor 1. inteiro: n; n 4; escreva (n); n n + 4; até (n = 200); 17. Elaborar um algoritmo que apresente os valores de conversão de graus Celsius em graus Fahrenheit, de dez em dez graus, iniciando a contagem em dez graus Celsius e finalizando em cem graus Celsius. O algoritmo deve mostrar os valores das duas temperaturas. inteiro: C, F; C 10; F (C * 1,8) + 32; escreva (C, F); C C + 10; até (C > 100); 18. Elaborar um algoritmo que leia dez valores numéricos reais e apresente no final o somatório e a média dos valores lidos.

11 inteiro: cont; real: valor, soma, media; leia (valor); soma soma + valor; até (cont > 10); media soma / 10; escreva (soma, media); 19. Elaborar um algoritmo que leia sucessivamente valores numéricos e apresente no final o somatório, a média e o total de valores lidos. O algoritmo deve ler os valores enquanto o usuário estiver fornecendo valores positivos. Ou seja, o algoritmo deve parar quando o usuário fornecer um valor negativo (menor que zero). inteiro: qtde; real: valor, soma, media; qtde 0; leia (valor); se (valor >= 0) então soma soma + valor; qtde qtde + 1; fim; até (valor < 0); se (qtde > 0) então media soma / qtde; escreva (soma, media, qtde); fim; senão escreva ( Nenhum valor foi fornecido. );

12 20. Elaborar um algoritmo que apresente os resultados da soma e da média aritmética dos valores pares situados na faixa numérica de 50 a 70. inteiro: n, soma; real: media; n 50; soma soma + n; n n + 2; até (n > 70); media soma / 11; // existem 11 números pares entre 50 e 70 escreva (soma, media); 21. Elaborar um algoritmo que leia valores positivos inteiros até que um valor negativo seja informado. Ao final devem ser apresentados o maior e o menor valores informados pelo usuário. inteiro: cont, valor, maior, menor; leia (valor); se (valor >= 0) então se (cont = 1) então menor valor; maior valor; fim; senão se (valor > maior) então maior valor; senão se (valor < menor) então menor valor; até (valor < 0); escreva (menor, maior);

13

14 CUIDADO COM OS LAÇOS DE REPETIÇÃO REPITA-ATÉ INFINITOS! lógico: teste; teste verdadeiro; escreva ( Eu sou um loop infinito! ); até (teste = falso); escreva ( Eu sou um loop infinito! ); até (1 <> 1); caracter: sexo; sexo M ; escreva ( Eu sou um loop infinito! ); até (sexo <> M ); inteiro: X; X 1; escreva ( Eu sou um loop infinito! ); até (X = 2); inteiro: X, Y; X 1; Y X; escreva ( Eu sou um loop infinito! ); até (X <> Y); inteiro: X; X 1; escreva ( Eu sou um loop infinito! ); até (X >= 10); inteiro: X; X 2; escreva ( Eu sou um loop infinito! ); X 1; até (X = 2);