Estruturas de Repetição

Estruturas de Repetição

Introdução Muitas vezes devemos repetir um trecho do algoritmo diversas vezes, até que seja atendida uma condição específica.

Fluxograma de repetição
# repetições Atendido? Instruções a serem repetidas não sim

Em determinadas situações, repetir instruções se torna confuso ou trabalhoso Nestes casos, utilizamos as estruturas de repetição, que permitem executar mais de uma vez (repetir) um determinado trecho do algoritmo Estas estruturas permitem a repetição de um comando, ou bloco de comandos, um número determinado de vezes ou tantas vezes quantas uma condição lógica permita.

O trecho do algoritmo em repetição é também chamado de laço (ou “loop”) As repetições devem ser sempre finitas

Exemplo 1 Faça um algoritmo que calcule a média anual de um aluno, a partir de suas 4 notas bimestrais fornecidas.

Exemplo 1: Solução Algoritmo “Exemplo1” var N1,N2,N3,N4 : real // notas bimestrais MA : real // media inicio leia(N1,N2,N3,N4) // entrada de dados MA <- (N1+N2+N3+N4)/4 // calculo da media se (MA >=6) então escreva(“Aluno aprovado”) fimse fimalgoritmo

Exemplo 1: Solução Considere o algoritmo apresentado anteriormente
Observe que o algoritmo processa a média de um único aluno. E se existirem mais alunos? Podemos escrever o algoritmo para cada aluno. Assim sendo teremos de escrever 50 vezes o código se existirem 50 alunos. Solução simples porém inviável!

Exemplo 1: Solução Outra solução:
Depois de executar o comando que escreve a situação de um aluno fazer com que o comando para a leitura de dados fosse executado novamente. Este procedimento seria repetido mais 49 vezes. A estes trechos do algoritmo que são repetidos damos o nome de loop ou laço de repetição.

Exemplo 1: Solução Para construir um laço de repetição pode-se proceder de dois modos: Calcular a média enquanto a quantidade de médias calculadas for menor ou igual a 50. Isto representa uma repetição com teste no início. Calcular a média até que o número de médias calculadas atinja 50. Isto representa uma repetição com teste no fim.

Repetição com Teste no Início
Permite repetir um mesmo trecho de algoritmo diversas vezes, porém verificando antes de cada execução se é “permitido” executar o mesmo trecho. Trata-se de um laço que se mantém repetindo enquanto uma dada condição permanecer verdadeira A repetição acontece enquanto a condição lógica relacionada for verdadeira.

Para isto utiliza-se a estrutura que apresenta o seguinte formato: enquanto <condição> faça // bloco ou comando comando 1 comando 2 ... comando n fimenquanto

A instrução enquanto…faça…fimenquanto executa as instruções posicionadas entre o enquanto…faça e a instrução fimequanto, enquanto a condição for verdadeira

Na elaboração de algoritmos com esta estrutura torna-se necessário o uso de dois tipos de variáveis: as variáveis contadoras e as acumuladoras. Uma variável contadora é uma variável que recebe um valor inicial antes do início de uma estrutura de repetição e é incrementada no interior da estrutura de um valor constante, geralmente 1 (um), conforme o exemplo a seguir:

var CON : inteiro inicio CON <- 0; //Contadora => inicialização com valor 0 (zero) enquanto CON < 3 faca CON = CON + 1 //Contadora é incrementada da //constante 1 (um) fimenquanto fim Incremento Significa aumentar o que já existe em uma variável. Normalmente o incremento é de 1. Ex: x=x+1

Repetição com Teste no Início: Contadores
Contador: Variável que reproduz o processo de contagem var CON : inteiro início CON ¬ 0 enquanto CON < 3 faça CON ¬ CON + 1 fimenquanto fim CON 3 2 1

Exemplo 2 Calcular a média aritmética anual para 50 alunos sendo que são fornecidos suas 4 notas bimestrais. Espera-se, para cada aluno, o cálculo e resultado da sua média e a mensagem “Aluno aprovado, Parabéns!” Quando a média for >=7 ou “Aluno reprovado, estude mais!” quando contrário. Utilize o enquanto faça.

Exemplo 2: Solução Algoritmo “Exemplo2”
// Média Aritmética para 50 alunos var N1, N2, N3, N4 : real // notas bimestrais MA : real // média anual CON : inteiro // contador Início CON ¬ 0; // inicialização do contador enquanto (CON < 50) faca // teste da condição de parada leia (N1, N2, N3, N4) MA ¬ (N1 + N2 + N3 + N4) / 4 escreva (MA) se (MA >= 7) então escreva (“Aluno Aprovado. Parabéns!”) senão escreva (“Aluno Reprovado. Estude mais!”) fimse CON ¬ CON + 1; // incremento do contador fimenquanto fimalgoritmo

Repetição com Teste no Início: Acumuladores
Uma variável acumuladora é uma variável que recebe um valor inicial, geralmente 0 (zero) antes do início de uma estrutura de repetição, e é incrementada no interior da estrutura de um valor variável, geralmente a variável usada na estrutura de controle, conforme o exemplo a seguir:

var CON, X, ACM: inteiro inicio CON <- 0 ACM <- 0 //ACM é o acumulador enquanto CON < 3 faca CON = CON + 1 leia (X) ACM <- ACM + X fimenquanto fim

Acumulador: Variável que reproduz o processo de acumulação var CON, X, ACM: inteiro início CON ¬ 0 ACM ¬ 0 enquanto CON < 3 faça CON ¬ CON + 1 leia (X) ACM ¬ ACM + X fimenquanto fim CON ACM X 1 3 2 11 5 7 4 5 2

Exemplo 3 Obter a média aritmética para 50 alunos, sendo que é lido a média da cada aluno. Utilize a estrutura de repetição enquanto - faça.

Exemplo 3: Solução Como escrever um algoritmo que calcule a média aritmética das 50 médias anuais? Podemos em cada execução do laço de repetição acumular em uma variável (o acumulador) o somatório das médias anuais de cada aluno. Após o término da repetição dividimos o valor armazenado no acumulador por 50.

Exemplo 3: Resolução Algoritmo “Exemplo3”
// Média Aritmética da turma de 50 alunos. Exemplo com Acumulador var MA : real // média anual de dado aluno ACM : real // Acumulador MAT : real // Média Anual da Turma CON: inteiro // contador inicio CON ¬ 0; // inicialização do contador ACM ¬ 0; // inicialização do acumulador enquanto (CON < 50) faça // teste da condição de parada leia (MA) ACM ¬ ACM + MA // soma em ACM os valores lidos em MA CON ¬ CON + 1 // incremento do contador fimenquanto MAT ¬ ACM / 50 // calculo da média anual da turma escreva (“Média anual da turma = “, MAT) fimalgoritmo

Exemplo 4 - Variando o critério da parada
O algoritmo anterior utiliza um pré-conhecimento da quantidade de alunos da turma. E se não soubermos a quantidade alunos que a turma tem como poderemos controlar o laço de repetição? Teremos de encontrar outro critério de parada. Isto pode ser feito utilizando um valor pré-definido como finalizador de uma sequência de valores

Exemplo 4 - Variando o critério da parada: Solução
Algoritmo “Exemplo4” var MA : real // média anual de cada aluno ACM : real // acumulador MAT : real // media anual da turma CON : inteiro // contador inicio CON <- 0 ACM <- 0 Leia(MA) Enquanto (MA <> -1) ACM <- ACM + MA // acumula as medias de cada aluno CON <- CON+1 fimenquanto MAT <- ACM/CON Escreva(“Media anual da turma =“, MAT) fimalgoritmo

Exemplo 4 - Variando o critério da parada: Solução
Observe no algoritmo que: Usou-se o valor -1 como finalizador. Quando é encontrado (lido) o loop é finalizado sem que este valor seja computado ao acumulador. A leitura da primeira média anual (MA) acontece antes do laço de repetição

Modificações na estrutura: Pode-se usar condições múltiplas de parada: Ex. Digitar valores entre 1 e 10 enquanto ( (x >= 1) E (x <=10)) faca ... fimenquanto

Repetição com Teste no Final (Repita...até)
Para realizar a repetição com teste no final utilizamos a estrutura repita...até. A estrutura permite que um bloco de comandos seja repetido até que uma determinada condição seja verdadeira. A repetição acontece até uma condição lógica relacionada tornar-se verdadeira.

As instruções posicionadas entre o repita e a instrução até são executadas pelo menos uma vez independente da condição ser verdadeira ou não. Depois de cada execução, a estrutura verifica se é “permitido” continuar executando o trecho do algoritmo. Caso a condição seja verdadeira, estrutura de repetição continua

Forma geral da estrutura repita: repita | {bloco ou comando} até <condição>;

Pela sintaxe da estrutura observe que o bloco de comandos será executado no mínimo uma vez. Isto ocorre porque o cálculo da condição acontece depois da execução do bloco.

Algoritmo nome () Início /* instruções antes faça enquanto */ faça /*instrucões do faça enquanto*/ enquanto ( condição ) /*instruções após o faça enquanto*/ fim

Exemplo 5 Obter a média aritmética para 50 alunos, sendo que é lido a média da cada aluno. Utilize a estrutura de repetição com teste no final (repita...até)

Exemplo 5: Solução Algoritmo “Exemplo5” var MA : real // média anual de dado aluno ACM : real // acumulador MAT : real // média Anual da Turma CON : inteiro // contador início CON <- 0 // inicialização do contador ACM <- 0 // inicialização do acumulador repita leia (MA) ACM <- ACM + MA // soma em ACM os valores lidos em MA CON <- CON + 1 // incremento do contador ate (CON >= 50) // teste da condição de parada MAT <- ACM / 50 // calculo da média anual da turma escreva (“Média anual da turma = “, MAT) fimalgoritmo

Modificações na estrutura: Pode-se usar condições múltiplas de parada: Ex. Digitar valores entre 1 e 10 repita leia (x) ate ( (x < 1) OU (x > 10) )

Repetição com Variável de Controle
Nas estruturas de repetição vistas até agora um bloco de comandos será executado enquanto uma condição permaneça verdadeira ou até que uma condição seja satisfeita. Podemos usar um outra estrutura: a estrutura PARA. A estrutura PARA repete a execução do bloco um número definido de vezes.

PARA é um laço simplificado para utilização em repetições de quantidade predeterminada Incorpora internamente o funcionamento de um contador de repetições

Quando o número de repetições a ser executado é conhecido, usamos a seguinte estrutura: Para <controle>←<valor inicial> até <valor final> passo <passo> faça <comandos> Fimpara

Todas as instruções que estejam posicionadas entre o para… e a instrução fimpara são repetidas número previsto de vezes. Ao executar o número de repetições, a execução segue a para os próximos comandos após a instrução fimpara

Nesta estrutura, uma variável de controle é utilizada para contar as repetições de valor inicial até valor final, com uma diferença entre valores igual ao passo. Depois de atingido o valor final, a execução do algoritmo continua com os comandos após o “fimpara”.

A repetição acontece um número determinado de vezes, de forma automática. para V de vi até vf passo p faça | {bloco ou comando} fimpara Onde: V é a variável de controle; vi é o valor inicial da variável V; vf é o valor final da variável V, ou seja, o valor até o qual ela pode chegar; p é o valor do incremento dado à variável V.

Repetição: PARA Algoritmo ExemploPara início
/* instruções antes do para */ para <condição> passo faça /*instrucões do para*/ fimpara /*instruções após o para*/ fim

Repetição: PARA Algoritmo ExemploPara Início
/* instruções antes do para */ para <condição> passo faça /*instrucões do para*/ fimpara /*instruções após o para*/ fim

Exemplo 6 Faça um algoritmo que calcule a Média Aritmética das notas de uma turma de 50 alunos. As notas de cada aluno deverão ser informadas pelo usuário. Utilize a estrutura PARA.

Exemplo 6: Solução algoritmo "Exemplo6" var
nota: real // nota de aluno total: real // Acumulador media: real // Média da Turma cont : inteiro // contador inicio total <- 0; // inicialização do acumulador para cont de 1 ate 50 passo 1 faca escreva("Digite a nota do aluno ", cont, ": ") leia (nota) total <- total + nota; // soma em total os valores lidos em nota fimpara; media <- total / 50; // calculo da média anual da turma escreva (“Média anual da turma = ", media) fimalgoritmo

Repetição: PARA Modificações possíveis:
Incremento com valor acima de 1: para x de 1 ate 100 PASSO 2 faca ... Fimpara Ordem decrescente: para x de 10 ate 1 PASSO -1 faca fimpara

Comparação entre Estruturas de Repetição
Quanto a quantidade de repetições, os laços podem ser Pré-determinados: Sabe-se antes a quantidade de execuções Indeterminados: Não se conhece a quantidade de execuções Quanto ao critério de parada, os laços podem utilizar Teste no início Teste no final Variável de controle

Aprendemos 3 maneiras de construir laços de repetição É importante perceber que existem laços mais adequados ou convenientes para cada situação Estrutura Condição Quantidade de Execuções Condição de Existência Enquanto Início zero ou muitas Condição verdadeira Repita Final uma ou muitas Condição falsa Para Não tem ((vf - vi) div p) + 1 v <= vf

Uma estrutura de repetição obrigatoriamente possui: Uma variável de controle. Usada para contar quantas vezes o laço se repete Um incremento. Usado para aumentar ou diminuir o valor da variável de controle. Pode ser por atribuição ou por digitação do usuário. Um teste lógico. Usado para verificar se a condição de parada foi atingida.

Estruturas de Repetição

Apresentações semelhantes

Apresentação em tema: "Estruturas de Repetição"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback

Login

Autorizar-se através da rede social:

Estruturas de Repetição

Apresentações semelhantes

Apresentação em tema: "Estruturas de Repetição"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback