WEBCONFERÊNCIA II - PC - Programação de Computadores (Unid 2) (1)

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

Programação de Computadores 
WEBCONFERÊNCIA II 
Prof. Leopoldo França 
2 
Estruturas de repetição 
• Diferente do ser humano, o computador não se cansa de realizar 
operações repetitivas. 
• Diante disto, podemos incluir nos algoritmos as estruturas de repetição. 
• O que é uma repetição? 
• Também chamada a laço ou loop; 
• É uma instrução que permite a execução de um trecho de algoritmo várias vezes 
seguidas. 
• Nesta aula veremos: 
• Repetição com teste no início; 
• Repetição com teste no final; 
• Repetição com variável de controle. 
3 
Comandos REPITA e ENQUANTO 
• Tanto o comando REPITA quanto o comando ENQUANTO 
permitem repetir um ou mais comandos no corpo de um 
algoritmo. 
• A sintaxe dos comandos é: 
repita 
 <comando1>; 
 <comando2>; 
 . 
 . 
 . 
 <comandoN>; 
até <expr>; 
enquanto <expr> faça 
 <comando>; 
4 
Comando REPITA 
• O comando REPITA indica que todos os comandos entre a palavra 
repita e a palavra até encontram-se dentro de um laço e devem ser 
executados. 
• Após a palavra até deve haver uma expressão lógica que: 
• Se falsa, indica que o laço deve ser executado novamente; 
• Se verdadeira, indica que o laço acabou e o algoritmo deve continuar sendo 
executado. 
• Esta estrutura é chamada de repetição com teste no final 
• A decisão entre repetir e parar o laço é feita ao final do comando. 
• É garantido que o laço será executado pelo menos uma vez. 
5 
Comando REPITA em VisuAlg 
•Teste realizado após a execução do corpo do loop. 
• O corpo do loop sempre executa ao menos uma vez. 
• O código continuará sendo executado enquanto a 
instrução for FALSA. 
 
repita 
 <sequência-de-comandos> 
ate <expressão-lógica> 
6 
Exemplo comando repita 
algoritmo "Números de 1 a 10 (com repita)" 
var j: inteiro 
inicio 
j <- 1 
repita 
 escreva (j:3) 
 j <- j + 1 
ate j > 10 
fimalgoritmo 
7 
Comando ENQUANTO 
• O comando ENQUANTO indica que o comando seguinte será executado, desde 
que o resultado da expressão lógica seja verdadeiro. 
 
• Apesar do ENQUANTO permitir apenas a repetição de um único comando, 
nada impede que seja utilizado um bloco de comandos. 
 
• Ao encontrar o fim do comando (ou do bloco), o computador volta para a 1ª 
linha do laço e avalia novamente a expressão lógica: 
• Se verdadeira, o computador fará uma nova execução do trecho; 
• Se falsa, o computador interrompe a execução e continua no próximo comando após o 
trecho repetido. 
 
• Esta estrutura é chamada de repetição com teste no início 
• A decisão entre repetir e parar o laço é feita no início do comando. 
• Se o teste for falso desde o início, o laço não será executado. 
8 
Comando Enquanto em VisuAlg 
• Implementado com a instrução enquanto .. faca 
• instrução que efetua o teste antes da execução do corpo do 
loop. 
• O corpo do loop pode nunca ser executado. 
• Esta estrutura repete uma seqüência de comandos enquanto uma 
determinada condição (especificada através de uma expressão 
lógica) for satisfeita. 
 
enquanto <expressão-lógica> faca 
 <sequência-de-comandos> 
fimenquanto 
9 
Exemplo comando enquanto .. faca 
algoritmo "Números de 1 a 10 (enquanto..faca)" 
var j: inteiro 
 
inicio 
j <- 1 
enquanto j <= 10 faca 
 escreva (j:3) 
 j <- j + 1 
fimenquanto 
fimalgoritmo 
10 
Comandos REPITA e ENQUANTO 
•Exercício: 
• Fazer um programa para ler diversos pares de notas 
informados pelo usuário. Cada par de nota deve ser 
calculado a média dessas duas notas. Após cada leitura 
exibir a média das duas notas lidas. Considere que 
depois da exibição da média seja perguntado ao usuário 
se ele deseja finalizar o programa ou calcular mais, com 
a seguinte mensagem: “Digite 0 (zero) para finalizar o 
programa:”. 
11 
Comandos REPITA e ENQUANTO 
•Solução 
•Quantos dados serão fornecidos? 
•Quantas variáveis serão necessárias? 
•Temos que identificar o trecho que será repetido e 
adicioná-lo dentro de um comando de repetição, 
declarando apenas as variáveis necessárias para 
uma repetição. 
12 
Comandos REPITA e ENQUANTO 
• Solução usando repita(cont.) 
• O algoritmo fica assim: 
Variáveis 
 n1, n2, m : real; 
 res : inteiro; 
Início 
 repita 
 escreva “Digite a nota 1: ”; 
 leia (n1); 
 escreva “Digite a nota 2: ”; 
 leia (n2); 
 m <- (n1+n2)/2; 
 escreva “Média = ”, m; 
 escreva “Digite 0 (zero) para finalizar o programa: ”; 
 leia (res); 
 até res = 0; 
Fim 
13 
Solução em VisuAlg usando REPITA 
var 
 n1, n2, m : real 
 res : inteiro 
 
inicio 
 repita 
 escreva("Digite a nota 1: ") 
 leia(n1) 
 escreva("Digite a nota 2: ") 
 leia(n2) 
 m <- (n1+n2)/2 
 escrevaL("Média = ", m) 
 escreva("Digite 0(zero) para finalizar o programa") 
 leia(res) 
 ate res = 0 
fimalgoritmo 
14 
Variáveis contadoras 
• Uma variável é chamada de contadora quando armazena 
dentro de si um número referente a uma certa quantidade 
de elementos ou iterações. 
• Este tipo de variável é muito comum em estruturas de 
repetição, dada as suas diversas aplicações em problemas 
que envolvem contagens de valores. 
• Exemplo: 
• Imprimir todos os números inteiros de 1 a 100. 
15 
Variáveis contadoras 
• Solução 
• O algoritmo não tem dados de entrada, e fica assim: 
Variáveis 
 valor : inteiro; 
Início 
 escrever “Valores inteiros de 1 a 100”; 
 valor = 1; 
 repita 
 escrever valor; 
 valor = valor + 1; 
 até valor > 100; 
Fim 
É possível resolver 
utilizando o ENQUANTO? 
16 
Programa em VisuAlg 
algoritmo "exemplo" 
var 
 valor: inteiro 
inicio 
 escrevaL ("Valores inteiros de 1 a 100") 
 valor <- 1 
 repita 
 escrevaL ( valor ) 
 valor <- valor + 1 
 ate valor > 100 
fimalgoritmo 
17 
Variáveis contadoras 
• Solução 
• Utilizando o ENQUANTO o algoritmo fica assim: 
Variáveis 
 valor : inteiro; 
Início 
 escrever “Valores inteiros de 1 a 100”; 
 valor = 1; 
 enquanto valor <= 100 faça 
 [[ 
 escrever valor; 
 valor = valor + 1; 
 ]]; 
Fim 
18 
Variáveis contadoras 
•Exercício: 
 
•Escrever um programa que leia 10 números 
inteiros fornecidos pelo usuário, e exiba 
quantos números ímpares foram informados. 
19 
Variáveis contadoras 
• Solução 
• Serão necessárias 10 leituras. Podemos criar uma variável 
contadora para controlar este laço. 
 
• Precisaremos de uma outra variável para contar a quantidade 
de números ímpares. 
• Não podemos deixar para contar após a repetição, pois cada número 
fornecido apaga o anterior. Logo precisamos ir contando após cada 
entrada, incrementando uma nova variável contadora. 
• Esta nova variável contadora só é incrementada se o número informado 
for ímpar. 
20 
Variáveis contadoras 
• Solução 
Variáveis 
 cont, num, qtd_impar : inteiro; 
Início 
 cont = 1; 
 qtd_impar = 0 
 enquanto cont <= 10 faça 
 [[ 
 escrever “Digite um número: ”; 
 ler num; 
 se num % 2 <> 0 então 
 qtd_impar = qtd_impar + 1; 
 cont = cont + 1; 
 ]]; 
 escrever “O total de ímpares foi “ , qtd_impar; 
Fim 
A variável é iniciada 
como 0 pois o usuário 
poderá informar 10 
números pares 
21 
Programa em VisuAlg 
algoritmo "exemplo" 
var 
 cont, num, qtd_impar : inteiro 
inicio 
 cont <- 1 
 qtd_impar <- 0 
 enquanto cont <= 10 faca 
 escreva ("Digite um número: ") 
 leia (num) 
 se num % 2 <> 0 entao 
 qtd_impar <- qtd_impar + 1 
 fimse 
 cont <- cont + 1 
 fimenquanto
escrevaL ("O total de ímpares foi " , qtd_impar) 
fimalgoritmo 
22 
Variáveis acumuladoras 
• Uma variável é chamada de acumuladora quando tem por 
característica armazenar dentro de si o resultado acumulado 
de uma série de valores. 
• Quando armazenamos a soma de uma quantidade pequena de 
números, a atribuição é direta. Numa repetição devemos 
armazenar a soma de diversos números sucessivos, e para isto 
utilizamos uma variável acumuladora. 
• Exemplo 
• Calcular a soma de diversos números reais informados pelo 
usuário. A entrada de dados termina com o número -999. 
23 
Variáveis acumuladoras 
• Solução 
• O algoritmo fica assim: 
Variáveis 
 num, soma : real; 
Início 
 soma = 0; 
 escrever “Para sair, entre com -999”; 
 escrever “Entre com o número: “; 
 ler num; 
 enquanto num <> -999 faça 
 [[ 
 soma = soma + num; 
 escrever “Entre com o número: “; 
 ler num; 
 ]]; 
 escrever “A soma foi ”, soma; 
Fim 
A variável é iniciada 
como 0 pois, caso o usuário 
forneça -999 na primeira 
execução, o valor total da 
soma é 0. 
24 
Laços infinitos 
• Ao trabalhar com repetições, é preciso tomar cuidado para 
não criar um laço infinito, ou seja, um laço que não termina. 
 
• Neste tipo de situação a máquina permaneceria executando o 
laço indefinidamente, até que ocorra uma intervenção 
externa. 
 
• Exemplo: 
• Imprimir os quadrados dos números inteiros de 1 a 10. 
25 
Laços infinitos 
•Solução: 
Variáveis 
 valor, quadrado : real; 
Início 
 escrever “Quadrados dos números inteiros de 1 a 10”; 
 escrever “Entre com o número: “; 
 valor = 1; 
 repita 
 quadrado = sqr(valor); 
 escrever quadrado; 
 valor = valor - 1; 
 até valor > 10; 
 escrever “Fim da impressão.”; 
Fim 
26 
Repetições encadeadas 
• Da mesma forma que é permitido o encadeamento de testes, 
também é possível encadear comandos de repetição. 
• Um encadeamento de repetições ocorre quando há 
necessidade de efetuar um laço dentro de outro. 
• Neste tipo de situação, o algoritmo possui repetições 
controladas por um teste interno e outro externo. 
• Exemplo 
• Imprimir as tabuadas de multiplicação dos números 3, 4, 5 e 6. 
27 
Repetições encadeadas 
• Solução 
Variáveis 
 num, mult, cont : inteiro; 
Início 
 num <- 3; 
 enquanto num <= 6 faça 
 [[ 
 escrever “Tabuada de ”, num; 
 cont = 1; 
 enquanto cont <= 10 faça 
 [[ 
 mult = num * cont; 
 escrever num, “x”, cont, “=“, mult; 
 cont = cont + 1; 
 ]]; 
 num = num + 1; 
 ]]; 
Fim 
28 
Comando PARA 
• É muito comum a existência de repetições que fazem uso de 
variáveis contadoras, especialmente para contagens de 1 em 1. 
 
• Para facilitar a construção deste tipo de laço, pode-se utilizar 
um outro comando de repetição complementar chamada 
PARA. Sua sintaxe é: 
para <var> de <valor_inicial> até <valor_final> faça 
 <comando>; 
29 
Comando PARA 
• Exemplo: 
• Escrever os números inteiros de 1 a 100. 
• Solução com o comando PARA: 
Variáveis 
 valor : inteiro; 
Início 
 escrever “Valores inteiros de 1 a 100”; 
 para valor de 1 até 100 faça 
 escrever valor; 
Fim 
30 
Comando PARA em VisuAlg 
• Esta estrutura repete uma seqüência de comandos um determinado 
número de vezes. 
 
para <variável> de <valor-inicial> ate <valor-limite> [passo <incremento>] faca 
 
 <sequência-de-comandos> 
 
fimpara 
 
 OBS: <valor-inicial >, <valor-limite > e <incremento > são avaliados uma única 
vez antes da execução da primeira repetição, e não se alteram durante a 
execução do laço, mesmo que variáveis eventualmente presentes nessas 
expressões tenham seus valores alterados. 
31 
Comando PARA em VisuAlg 
• No exemplo a seguir, os números de 1 a 10 são exibidos em ordem 
crescente. 
 
algoritmo "Números de 1 a 10“ 
var 
 j: inteiro 
inicio 
para j de 1 ate 10 faca 
 escreva (j:3) 
fimpara 
fimalgoritmo 
32 
Comando PARA em VisuAlg 
• Importante: Se, logo no início da primeira repetição, <valor-inicial > for maior que 
<valor-limite > (ou menor, quando <incremento> for negativo), o laço não será 
executado nenhuma vez. O exemplo a seguir não imprime nada. 
 
algoritmo "Numeros de 10 a 1 (não funciona)" 
var 
 j: inteiro 
inicio 
para j de 10 ate 1 faca 
 escreva (j:3) 
fimpara 
fimalgoritmo 
33 
Comando PARA em VisuAlg 
• Este outro exempo, no entanto, funcionará por causa do passo -1: 
 
algoritmo "Numeros de 10 a 1 (este funciona)" 
var 
 j: inteiro 
inicio 
para j de 10 ate 1 passo -1 faca 
 escreva (j:3) 
fimpara 
fimalgoritmo 
34 
Exemplo 1: 
•Calcule e exiba a soma de todos os números pares 
contidos entre zero e um número fornecido via 
teclado (caso o número fornecido seja par, o 
mesmo deverá fazer parte da soma). 
35 
Solução 
algoritmo "exemplo1" 
var 
 numero ,i , soma_pares: inteiro 
inicio 
soma_pares <-0 
escreva("Digite um número > 0:") 
leia(numero) 
se numero >0 entao 
 para i de 1 ate numero faca 
 se (i % 2 = 0) entao 
 soma_pares <- soma_pares + i 
 fimse 
 fimpara 
 escrevaL("A soma dos pares é: ", soma_pares) 
senao 
 escrevaL("Número inválido informado.") 
fimse 
fimalgoritmo