Estrutura de Repetição em Algoritmos

Prévia do material em texto

1 
LINGUAGEM E TÉCNICA DE PROGRAMAÇÃO I 
 
Profa. Gisele Busichia Baioco 
gisele@ft.unicamp.br 
 
 
Algoritmos Estruturados e 
Linguagem de Programação Estruturada 
 
Estrutura de Repetição em Algoritmos 
1 Visão Geral 
Uma estrutura de repetição (ou iterativa), também conhecida como laço ou loop, é 
uma estrutura de controle de fluxo de execução das instruções (comandos) de programas, que 
faz com que uma instrução ou um conjunto de instruções seja executado repetidamente, zero 
ou mais vezes. Pode ser dividida em três grupos: 
• Estrutura de repetição para número definido de repetições; 
• Estrutura de repetição para número indefinido de repetições pré-teste; 
• Estrutura de repetição para número indefinido de repetições pós-teste. 
2 Estrutura de Repetição para Número Definido de Repetições 
A estrutura de repetição para número definido de repetições é utilizada quando se 
sabe o número de vezes que um comando ou um conjunto de comandos deve ser repetido. 
O número de repetições é controlado por uma variável de contagem (ou contadora), na 
qual o valor da contagem é mantido. Deve-se especificar um valor inicial, um valor final e o 
passo para a contagem, fazendo com que a contagem seja crescente ou decrescente e ocorra 
de acordo com passo (de 1 em 1, de 2 em 2, de 3 em 3, etc). 
Esquematicamente tem-se: 
 2 
 
 
var ≤≤≤≤ valorf 
var ←←←← valori 
Verdadeiro 
Falso 
comando 
var ←←←← var + p 
var ≥≥≥≥ valorf 
var ←←←← valori 
Verdadeiro 
Falso 
comando 
var ←←←← var - p 
Contagem em ordem crescente: Contagem em ordem decrescente: 
 
 
Sintaxe em algoritmos: 
para var ← valori até valorf passo p faça 
 comando; 
onde: 
para, até, passo e faça: são as palavras reservadas do algoritmo para a estrutura de repetição; 
var: é a variável de contagem que vai contar de um valor inicial (valori) até um valor final 
(valorf); 
valori: é o valor inicial da variável de contagem (var), ou seja, o valor inicial da contagem; 
valorf: é o valor final da variável de contagem (var), ou seja, o valor final da contagem; 
p: é o valor do passo, ou seja, é o valor do incremento (contagem crescente) ou decremento 
(contagem decrescente) que será utilizado para a contagem; 
comando: qualquer instrução válida. 
 Caso seja necessária a execução de um conjunto de comandos, ou seja, de um bloco 
de comandos, deve-se utilizar os delimitadores de bloco início e fim.A sintaxe é a seguinte: 
para var ← valori até valorf faça 
início 
comando1; 
... 
comandoN; 
fim 
 
 
 3 
Algoritmos exemplo: 
 
Algoritmo 
 início 
 declare N1, N2, M, Mgeral, soma: numérico real; 
 cont: numérico inteiro; 
 soma ← 0; /* valor inicial para a sumarização das médias */ 
 para cont ← 1 até 50 passo 1 faça 
 início 
 escreva(“Digite as duas notas”); 
 leia(N1); 
leia(N2); 
 M ← (N1 + N2)/2; /* cálculo da média de um aluno */ 
 soma ← soma + M; /* sumariza as médias dos alunos */ 
 escreva(“Media do aluno ”, cont, “ = ”, M); 
 fim 
 Mgeral ← soma/50; /* cálculo da média geral dos 50 alunos */ 
 escreva(“Media geral da turma de alunos = ”, Mgeral); 
fim 
 
Algoritmo 
 início 
 declare N, cont: numérico inteiro; 
 escreva(“Digite um número inteiro positivo: ”); 
 leia(N); 
 escreva(“Seqüência de números pares até ”, N); 
 para cont ← 2 até N passo 2 faça 
 escreva(cont); 
 fim 
3 Estrutura de Repetição para Número Indefinido de Repetições Pré-Teste 
A estrutura de repetição para número indefinido de repetições pré-teste deve ser 
utilizada quando não se sabe o número de vezes que um comando ou um bloco de comandos 
deve ser repetido, embora também possa ser utilizada quando se sabe esse número. 
O número de repetições é controlado por uma condição representada por uma 
expressão lógica. O teste da condição de controle é realizado antes da execução do comando 
ou bloco de comandos, por isso essa estrutura de repetição é denominada pré-teste (teste no 
início). Desse modo, se a condição de controle for falsa logo na primeira comparação, o 
comando ou bloco de comandos da estrutura de repetição não será executado nenhuma vez. 
Esquematicamente tem-se: 
 
 
condição 
comando 
Verdadeira 
Falsa 
 
 
 4 
Sintaxe em algoritmos: 
enquanto (condição) faça 
 comando; 
onde: 
enquanto e faça: são as palavras reservadas do algoritmo para a estrutura de repetição; 
condição: é uma expressão lógica que, enquanto for verdadeira, fará com que o comando seja 
executado. Quando se tornar falsa, fará com que a execução de comando pare, ou seja, 
interrompe a repetição; 
comando: qualquer instrução válida. 
 Caso seja necessária a execução de um bloco de comandos, a sintaxe é a seguinte: 
enquanto (condição) faça 
início 
comando1; 
... 
comandoN; 
fim 
 
Algoritmos exemplo: 
Algoritmo 
 início 
 declare N, r: numérico inteiro; 
 escreva(“Entre com um numero inteiro”); 
 leia(N); 
 enquanto (N ≠ 0) faça 
 início 
 r ← resto(N, 2); 
 se (r = 0) 
 então 
 escreva(“O numero é par”); 
 senão 
 escreva(“O numero é ímpar”); 
 escreva(“Entre com outro numero inteiro”); 
 leia(N); 
 fim 
fim 
 
Algoritmo 
 início 
 declare N1, N2, M, Mgeral, soma: numérico real; 
 cont: numérico inteiro; 
 soma ← 0; /* valor inicial para a sumarização das médias */ 
 cont ← 1; /* inicialização da variável de contagem */ 
 enquanto (cont ≤ 50) faça 
 início 
 escreva(“Digite as duas notas”); 
 leia(N1); 
leia(N2); 
 M ← (N1 + N2)/2; /* cálculo da média de um aluno */ 
 soma ← soma + M; /* sumariza as médias dos alunos */ 
 escreva(“Media do aluno ”, cont, “ = ”, M); 
 cont ← cont + 1; /* incremento da variável de contagem */ 
 fim 
 Mgeral ← soma/50; /* cálculo da média geral dos 50 alunos */ 
 escreva(“Media geral da turma de alunos = ”, Mgeral); 
fim 
 5 
4 Estrutura de Repetição para Número Indefinido de Repetições Pós-Teste 
A estrutura de repetição para número indefinido de repetições pós-teste deve ser 
utilizada quando não se sabe o número de vezes que um comando ou um bloco de comandos 
deve ser repetido, embora também possa ser utilizada quando se sabe esse número. 
O número de repetições é controlado por uma condição representada por uma 
expressão lógica. O teste da condição de controle é realizado após a execução do comando ou 
bloco de comandos, por isso essa estrutura de repetição é denominada pós-teste (teste no 
final). Desse modo, a execução do comando ou bloco de comandos ocorre pelo menos uma 
vez antes que a condição de controle seja testada, o que difere a estrutura de repetição para 
número indefinido de repetições pós-teste da pré-teste. 
Esquematicamente tem-se: 
 
 
condição 
comando(s) 
Verdadeira 
Falsa 
 
Sintaxe em algoritmos: 
 repita 
 comando ou lista de comandos; 
 até (condição); 
onde: 
repita e até: são as palavras reservadas do algoritmo para a estrutura de repetição; 
condição: é uma expressão lógica que, enquanto for falsa, fará com que o comando ou a lista 
de comandos seja executada. Quando se tornar verdadeira, fará com que a execução pare; 
comando ou lista de comandos: qualquer instrução ou conjunto de instruções válidas. 
 Deve-se observar que a sintaxe é a mesma tanto para a execução de um comando 
quanto para a execução de um conjunto de comandos. 
Algoritmos exemplo: 
Algoritmo 
 início 
 declare N, r: numérico inteiro; 
 repita 
 escreva(“Entre com um numero inteiro”); 
 leia(N); 
 se (N ≠ 0) 
 então início 
 r ← resto(N, 2); 
 se (r = 0) 
 então escreva(“O numero é par”); 
 senão escreva(“O numero é ímpar”); 
 fim 
 até (N = 0); 
fim 
 6 
 
Algoritmo 
 início 
 declare N1, N2, M, Mgeral, soma: numérico real; 
 cont: numérico inteiro; 
 soma ← 0; /* valor inicial para a sumarização das médias */ 
 cont ← 1; /* inicialização da variável de contagem */ 
 repita 
 escreva(“Digite as duas notas”); 
 leia(N1); 
leia(N2);M ← (N1 + N2)/2; /* cálculo da média de um aluno */ 
 soma ← soma + M; /* sumariza as médias dos alunos */ 
 escreva(“Media do aluno ”, cont, “ = ”, M); 
 cont ← cont + 1; /* incremento da variável de contagem */ 
 até (cont > 50); 
 Mgeral ← soma/50; /* cálculo da média geral dos 50 alunos */ 
 escreva(“Media geral da turma de alunos = ”, Mgeral); 
fim 
5 Exemplos de Algoritmos 
1) Faça um algoritmo que calcule o fatorial de um número inteiro qualquer. Sabe-se que: 
0! = 1 
n! = 1*2*3*...*n-1*n, n > 0 
Solução: 
Entrada: número inteiro, num 
Processo: se for 0 ou 1 o fatorial = 1, caso contrário, fatorial = 2*3*...*num-1*num 
Saída: valor do fatorial 
Algoritmo 
início 
 /* Declaração de variáveis */ 
 declare num, fatorial, cont: numérico inteiro; 
 /* Entrada de dados */ 
 escreva(“Digite um número inteiro para o calculo do fatorial: ”); 
 leia(num); 
/* Processo – cálculo do fatorial */ 
fatorial ← 1; /* resolve o problema de fatorial de 0 e 1 */ 
para cont ← 2 até num passo 1 faça 
 fatorial ← fatorial * cont; 
escreva(“Fatorial = ”, fatorial); 
fim 
 
 7 
2) Anacleto tem 1.50 m de altura e cresce 2 centímetros por ano enquanto Felisberto tem 
1.10 m de altura e cresce 3 centímetros por ano. Construa um algoritmo que calcule e 
imprima quantos anos serão necessários para que Felisberto seja mais alto que 
Anacleto. 
Solução: 
Entrada: não tem dados de entrada. 
Processo: cálculo dos anos necessários para Felisberto ser mais alto que Anacleto 
Saída: valor dos anos 
Algoritmo 
início 
 /* Declaração de variáveis */ 
 declare alt_A, alt_F: numérico real; 
 anos: numérico inteiro; 
 /* Processo*/ 
 alt_A ← 1.50; /* inicializa a altura de Anacleto */ 
 alt_F ← 1.10; /* inicializa a altura de Felisberto */ 
 anos ← 0; /* inicializa o numero de anos */ 
 enquanto (alt_A ≥ alt_F) 
 início 
 alt_A ← alt_A + 0.02; 
 alt_F ← alt_F + 0.03; 
 anos ← anos + 1; 
 fim 
 escreva(“Anos = ”, anos); 
fim 
 
 8 
3) A nota final de um estudante é calculada a partir de três notas: laboratório, avaliação 
semestral e exame final, com os pesos 2, 3 e 5, respectivamente. Faça um algoritmo 
que leia três notas de um estudante e calcule e mostre a média ponderada, repetindo o 
processo até que o usuário deseje parar. 
Solução: 
 Para quantos estudantes o usuário desejar: 
Entrada: três notas, laboratorio, semestral, exame 
Processo: media = (laboratório * 2 + semestral * 3 + exame * 5) / 10 
Saída: valor da media 
Algoritmo 
início 
 /* Declaração de variáveis */ 
 declare laboratorio, semestral, exame, media: numérico real; 
 resp: caractere; 
 repita 
 /* Entrada de dados */ 
 escreva(“Digite a nota de laboratório: ”); 
 leia(laboratorio); 
 escreva(“Digite a nota da avaliação semestral: ”); 
 leia(semestral); 
 escreva(“Digite a nota do exame final: ”); 
leia(exame); 
/* Processo – cálculo da média ponderada */ 
media ← (laboratório * 2 + semestral * 3 + exame * 5) / 10; 
/* Saída de dados */ 
escreva(“Média ponderada = ”, media); 
escreva(“Deseja continuar(S/N)?”); 
leia(resp); 
 até (resp = ‘N’); 
fim 
 9 
6 Exercícios de Fixação 
1) Faça um algoritmo para determinar os divisores de um número qualquer. 
2) Construa um algoritmo que, dado um conjunto de valores inteiros e positivos, 
determine qual o menor e o maior valor do conjunto. O final do conjunto de valores é 
determinado pelo valor –1, que não deve ser considerado. 
3) Calcule o imposto de renda de N contribuintes, considerando que os dados de cada 
contribuinte número do CPF, número de dependentes e renda mensal, são valores 
fornecidos pelo usuário. Para cada contribuinte serão deduzidos 5% da renda mensal 
correspondente a cada dependente. Os valores da alíquota para cálculo do imposto são: 
 
Renda Líquida Alíquota 
Até 2 salários mínimos Isento 
De 2 a 3 salários mínimos. 5% 
De 3 a 5 salários mínimos. 10% 
De 5 a 7 salários mínimos. 15% 
Acima de 7 salários mínimos 20% 
 Obs: O valor atual do salário mínimo deve ser fornecido pelo usuário. 
4) Elabore um algoritmo que leia números reais até que o valor da soma destes números 
seja ≥ 100. O algoritmo deverá fornecer ao final, quantos valores lidos foram 
necessários para satisfazer tal condição. 
5) Elabore um algoritmo que calcule e escreva a soma de todos os números ímpares que 
são múltiplos de 3 e que se encontram no conjunto dos números de 1 até 500.