CAMPUS DE GUARATINGUETÁ FACULDADE DE ENGENHARIA. Introdução à Programação em C. Algoritmos: Estruturas de Repetição. Prof. Dr. Galeno.J.

Transcrição

1 Unesp UNIVERSIDADE ESTADUAL PAULISTA CAMPUS DE GUARATINGUETÁ FACULDADE DE ENGENHARIA Introdução à Programação em C Algoritmos: Estruturas de Repetição Prof. Dr. Galeno.J. de Sena Departamento de Matemática Edição: 2011 Notas de aula organizadas a partir das referências citadas ao final do texto

2 Capítulo 4 Algoritmos: Estruturas de Repetição Permitem que o fluxo de execução repita um certo trecho de um algoritmo designado de laço de repetição, um certo número de vezes. O número de repetições pode ser indeterminado, porém deve ser finito. Observação: laços de repetição também são designados de loops ou loopings Repetição com teste no início Permitem repetir diversas vezes um mesmo trecho do algoritmo, porém sempre verificando antes de cada execução se é permitido executar o mesmo trecho. Estrutura enquanto Forma geral: enquanto (condição) faça início // início do laço de repetição C1; // seqüência de comandos C2; Cn; fim // fim do laço de repetição Esta estrutura permite que um bloco ( laço de repetição ), ou uma ação primitiva 1, sejam repetidos enquanto uma determinada condição for verdadeira. Antes de se iniciar a repetição, a condição é avaliada. Se o resultado da avaliação for verdadeiro, o laço será executado. Ao término de sua execução, a condição é reavaliada. Quando o resultado da avaliação da condição for falso, o laço deixa de ser executado, prosseguindo-se com o comando que segue a estrutura enquanto. Exemplo: algoritmo para calcular a média de 50 alunos Variável contadora ou contador: utilizada para contar quantos alunos foram processados, é uma variável com um dado valor inicial o qual é incrementado (acrescido de um valor constante, normalmente 1) a cada passo da repetição. Por exemplo, o ponteiro de segundos de um relógio é um contador de segundos. O trecho de algoritmo a seguir ilustra a utilização de um contador: // uso de contador em algoritmo inteiro: CON; CON 0; // inicialização 1 Corresponde a um laço de repetição com um único comando.

3 enquanto (... ) faça início // início do laço de repetição CON CON + 1; // incrementa o contador fim // fim do laço de repetição Codificação do algoritmo: Algoritmo: cálculo da média aritmética para 50 alunos início // Cálculo da média aritmética para cada um dos 50 alunos // alunos de uma turma, c/ verificação qto à aprovação // declaração de variáveis real: N1, N2, N3, N4, // notas bimestrais MF; // media final inteiro CON; // contador // inicialização do contador CON 0; // processamento: o cálculo da média é repetido para // 50 alunos enquanto (CON < 50) faça // entrada de dados leia(n1, N2, N3, N4); // calculo da média MF (N1 + N2 + N3 + N4) / 4; // verificação quanto à aprovação se (MF >= 7.0) então // gera saídas: aluno aprovado escreva( Media =, MF); escreva( Aprovado! ); fim; senao // MF < 7.0 // gera saídas: aluno reprovado escreva( Media =, MF); escreva( Reprovado! ); fim; CON CON + 1; // incrementa o contador: proximo aluno fim; // enquanto escreva( processamento finalizado! ); fim // algoritmo: cálculo da média final.

4 Exemplo: algoritmo para o cálculo da média geral de uma turma, com as médias individuais sendo fornecidas em tempo de execução. O cálculo direto: MT M1 M 2 M 3 M 4 M 5 M 49 M 50 /50; mostra-se inviável. Uma maneira mais apropriada para se resolver este problema é acumular as médias de cada aluno, utilizando uma variável acumuladora ou um acumulador. Uma variável acumuladora tem, a cada execução de um laço, o seu valor corrente somado a um novo valor (que se deseja somar), o resultado da soma sendo armazenado na variável ( acumulado ). Note-se que se trata de uma operação muito similar à realizada com uma variável contadora, diferenciando no fato de que o valor a ser incrementado não é constante a cada execução do laço, que é o caso para variáveis contadoras. Note-se também que é comum o uso de ambas as variáveis em estruturas de repetição. O trecho de algoritmo a seguir ilustra a utilização de um acumulador: // uso de acumulador em algoritmo inteiro: ACM, // acumulador X; ACM 0; // inicialização enquanto (... ) faça início // início do laço de repetição ACM ACM + X; // acumula em ACM o valor de X fim // fim do laço de repetição Codificação do algoritmo: Algoritmo: cálculo da média geral de uma turma início // Cálculo da média das médias dos 50 alunos // de uma turma, com as médias individuais sendo // fornecidas em tempo de execução // declaração de variáveis real: MF, // media final de um aluno ACM, // acumulador MT; // media da turma inteiro CON; // contador // inicialização: contador e acumulador CON 0; ACM 0; // processamento: lê e acumula as médias de 50 alunos

5 enquanto (CON < 50) faça // entrada de dados leia(mf); ACM ACM + MF; // acumula a média CON CON + 1; // incrementa o contador: proximo aluno fim; // enquanto // calculo e saída da media da turma MT ACM / 50; escreva( Media da turma:, MT); fim // algoritmo: cálculo da média geral de uma turma. Exemplo: algoritmo para o cálculo das médias dos alunos de uma turma, verificando a situação de cada aluno quanto à aprovação, e da média geral de uma turma, apresentada ao final. Este algoritmo corresponde a uma combinação dos dois algoritmos anteriores. Codificação do algoritmo: Algoritmo: cálculo de médias e verificação quanto aprovação início // Cálculo da média aritmética para cada um dos 50 alunos // alunos de uma turma, c/ verificação qto à aprovação; // calculo da média geral da turma // declaração de variáveis real: N1, N2, N3, N4, MF, // notas bimestrais média final ACM, MT; // acumulador e media da turma inteiro CON; // contador // inicialização: contador e acumulador CON 0; ACM 0; // processamento: calcula as médias dos // 50 alunos, acumulando-as enquanto (CON < 50) faça // entrada de dados (notas) leia(n1, N2, N3, N4); // calculo e saída da média MF (N1 + N2 + N3 + N4) / 4; escreva( Media =, MF); // verificação quanto à aprovação se (MF >= 7.0) então // gera saídas: aluno aprovado escreva( Aprovado! ); senao // MF < 7.0 // gera saídas: aluno reprovado escreva( Reprovado! );

6 // acumula media do aluno e incrementa contador ACM ACM + MF; // soma a media CON CON + 1; // mais um aluno processado fim; // enquanto // calculo e saída da media da turma MT ACM / 50; escreva( Media da turma:, MT); fim // algoritmo: cálculo de médias e verificação // quanto a aprovação. Uma situação que ocorre com freqüência é a necessidade de se repetir um laço um número indeterminado de vezes. Neste caso, faz-se necessário estabelecer um critério de parada apropriado. Exemplo: algoritmo para o cálculo da média de um conjunto de números inteiros positivos. A quantidade de números não é conhecida a priori. Resolução: x representa um número inteiro positivo; x 0 parar! (condição de parada). Codificação do algoritmo: Algoritmo: cálculo da média de um conjunto de números. início // Cálculo da média de um conjunto de números inteiros // positivos: o processamento é repetido até que se // forneça um valor negativo ou nulo // declaração de variáveis inteiro: x, // número CON, // contador ACM; // acumulador real: MD; // media // inicialização: contador e acumulador CON 0; ACM 0; // entrada do primeiro número leia(x); // processamento: acumula soma de números válidos enquanto (x > 0) faça CON CON + 1; // mais um número ACM ACM + x; // acumula o valor lido leia(x); // leitura de mais um numero, valido ou não fim; // enquanto // calculo da media: somente se houver

7 // pelo menos um valor de x válido se (CON > 0) entao MD ACM/CON; escreva( Media =, MD); fim senao escreva( Nenhum valor válido fornecido! ); fim // algoritmo: cálculo da média de um conj de números. Exemplo: algoritmo para o cálculo da média aritmética de um conjunto de números pares positivos. A execução deverá ser finalizada ao se fornecer um valor negativo ou impar. Resolução: N par resto( N / 2) 0 Codificação do algoritmo: Algoritmo: cálculo da média de um conjunto de números pares início // Cálculo da média de um conjunto de números pares e // positivos: o processamento é repetido até que se // forneça um valor negativo ou ímpar // declaração de variáveis inteiro: N, // número CON, // contador ACM; // acumulador real: MD; // media // inicialização: contador e acumulador CON 0; ACM 0; // entrada do primeiro número leia(n); // processamento: acumula soma de números válidos enquanto (N > 0 e N mod 2 = 0) faça CON CON + 1; // mais um número ACM ACM + N; // acumula o valor lido leia(n); // leitura de mais um numero, valido ou não fim; // enquanto // calculo da media: somente se houver // pelo menos um valor de x válido se (CON > 0) entao MD ACM/CON; escreva( Media =, MD); fim

8 senao escreva( Nenhum valor válido fornecido! ); fim // algoritmo: cálculo da média de um conj de // números pares positivos. Solução alternativa:... // inicialização: contador e acumulador CON 0; ACM 0; // valor valido para se iniciar o looping N 2 // processamento: acumula soma de números válidos enquanto (N > 0 e N mod 2 = 0) faça // leitura de um valor de N, valido ou não leia(n); // processa valor de N válido se (N > 0 e N mod 2 = 0) entao CON CON + 1; // mais um número ACM ACM + N; // acumula o valor lido fim; fim; // enquanto... Exercícios: 1) Modificar o algoritmo de cálculo da média aritmética de 50 alunos, para que seja calculada a média de N alunos N 5. 2) Modificar o algoritmo de cálculo da média aritmética das médias de uma turma de 50 alunos, para que seja calculada a média para uma turma de N alunos N 5. 3) Construir um algoritmo para calcular a média aritmética de um conjunto de números ímpares positivos. 4) Construir um algoritmo para calcular a soma dos N primeiros números pares. 5) Idem, para os N primeiros números ímpares. 6) Construir um algoritmo para gerar os números pares de 2 a N (N par e N 2 ). 7) Idem, para os números impares de 1 a N (N é ímpar e N 1).

9 8) João tem 1,40 m e cresce 2 cm por ano, ao passo que Antonio tem 1,15 m e cresce 3 cm por ano. Construa um algoritmo que calcule e mostre quantos anos serão necessários para que Antonio alcance ou ultrapasse João. 9) Construa um algoritmo que, dado um conjunto de valores inteiros e positivos, determine qual o maior valor do conjunto. O final do conjunto de valores é identificado pelo valor 0, que não deve ser considerado. 10) Escreva um algoritmo que gere e apresente os 20 primeiros termos da seqüência dos termos de Fibonacci: ) Construa um algoritmo que leia um conjunto de dados para 50 pessoas contendo a altura e o sexo (M para masculino e F para feminino), obtendo, a partir destes dados, as seguintes informações: a) a maior e a menor altura do grupo; b) a média de altura das mulheres; c) o percentual e o número de homens no conjunto de dados; d) o percentual e o número de mulheres no conjunto de dados. 12) Em uma eleição há quatro candidatos. Os votos são informados por código, os dados para a apuração obedecendo à seguinte codificação: 1, 2, 3, 4: voto para o respectivo candidato; 5: voto nulo; 6: voto em branco. Elabore um algoritmo que calcule e escreva: O total de votos para cada candidato e seu percentual sobre o total; O total de votos nulos e o seu percentual sobre o total; O total de votos em branco e o seu percentual sobre o total. A massa de dados de entrada será finalizada com o fornecimento de um valor 0 para o código. 13) Elaborar um algoritmo para calcular o valor de H a partir da soma a seguir: H ) Idem, para determinar o valor de S: S ) Construir um algoritmo para calcular a soma dos 10 primeiros termos da seguinte série: ) Modificar o algoritmo do exercício 13 para que H seja a soma dos N primeiros termos da série, com N 1.

10 4.2. Repetição com Variável de Controle A estrutura enquanto não enfatiza o número de vezes que um bloco de comandos será executado. Uma outra estrutura, designada para, repete a execução de um bloco um número predeterminado de vezes. Forma geral: para V de vi até vf passo p faça início C1; C2; Cn; fim Onde: V : variável de controle; vi: valor inicial de V; vf: valor final de V; p : valor do incremento dado à variável V. Esta estrutura corresponde então a um laço com contador compacto e tem a seguinte semântica (significado): V vi; // inicializa o valor de V para vi enquanto (V <= vf) // caso passo p positivo faça início C1; C2; Cn; V V + p; // incrementa o valor de V em p unidades fim; Observação: Caso o passo seja negativo, o valore de V decresce a cada execução do bloco, e a condição do enquanto se torna: enquanto (V >= vf) // caso passo p negativo Exemplo: algoritmo para o cálculo da média das médias dos alunos de uma turma. Solução com enquanto:... // inicialização: contador e acumulador CON 0; ACM 0; // processamento: lê e acumula as médias de 50 alunos

11 enquanto (CON < 50) faça leia(mf); // entrada de dados ACM ACM + MF; // acumula a média CON CON + 1; // incrementa o contador: proximo aluno fim; // enquanto // calculo e saída da media da turma MT ACM / 50;... Solução com para:... // inicialização: acumulador ACM 0; // processamento: lê e acumula as médias de 50 alunos para CON de 0 até 49 passo 1 faça leia(mf); // entrada de dados ACM ACM + MF; // acumula a média fim; // para // calculo e saída da media da turma MT ACM / 50;... Note-se que a variável contadora se torna a variável de controle da estrutura de repetição. Outra solução:... // inicialização: acumulador ACM 0; // processamento: lê e acumula as médias de 50 alunos para CON de 1 até 50 passo 1 faça leia(mf); // entrada de dados ACM ACM + MF; // acumula a média fim; // para // calculo e saída da media da turma MT ACM / 50;... Observação: é comum o uso de variáveis mais simples para contagem (variável de controle) e acumulação. Veja, por exemplo, o algoritmo a seguir, correspondente a uma variação do algoritmo para cálculo da média das médias dos alunos de uma turma.

12 ... // declaração de variáveis real: MF, // media final de um aluno S, // soma das médias (acumulador) MT; // media da turma inteiro i; // variável de controle (contador) do para // inicialização: soma das médias S 0; // processamento: lê e acumula as médias de 50 alunos para i de 1 até 50 passo 1 faça leia(mf); // entrada de dados ACM ACM + MF; // acumula a média fim; // para // calculo e saída da media da turma MT ACM / 50;... Exemplo: algoritmo para a geração dos 20 primeiros termos da sequencia dos termos de Fibonacci. Resolução: Seqüência dos termos de Fibonacci: Esquema para geração: ta tb tc Inicialmente: ta 1; tb 1; Do 3º termo em diante: tc ta + tb; ta tb; tb tc; Codificação do algoritmo: Algoritmo: geração dos 20 primeiros termos de Fibonacci início // Algoritmo para a geração dos 20 primeiros // termos da seqüência dos termos de Fibonacci // declaração de variáveis inteiro: ta, tb, tc, // termos da sequencia i; // contador (variável de controle)

13 // inicialização: termos iniciais ta 1; tb 1; // saída dos termos iniciais escreva( termo, 1, =, ta); escreva( termos, 2, =, tb); // processamento: determinação do 3 o ao 20 o termo para i de 3 até 20 passo 1 faça // calcula e mostra o i-esimo termo tc ta + tb; escreva( termo, i, =, tc); // atualiza termos anteriores ta tb; tb tc; fim; // para fim // algoritmo: geração 20 termos de Fibonacci. Exercícios: 1. Dada a elipse: x 2 2 y pede-se construir um algoritmo para determinar o número de pontos, com coordenados de valor inteiro, contidos no seu interior. 2. O cálculo da depreciação de um item, pelo método da cota fixa, é feito usando a equação: valori 1 depi, i 1,..., n n onde: dep i : depreciação no i-ésimo ano; n : tempo de vida previsto para um item em anos; valor 0 : custo do item. Por exemplo, a tabela de depreciação de um item com um custo de R$25.000,00 e vida útil de 5 anos, por este método, é a seguinte: ano depreciação valor atualizado , , , , ,00

14 , , , , , ,00 Obter um algoritmo para a construção da tabela de depreciação de um item específico. O valor inicial do item e sua vida útil deverão ser solicitados e lidos em tempo de execução. A saída do programa deverá ser na forma tabular. 3. Elaborar algoritmos para calcular a soma das séries a seguir, considerando N termos do desenvolvimento: (i) (ii) (iii) Construir dois algoritmos para calcular o valor de a partir das equações: (i) (ii) Construir dois algoritmos para calcular o valor aproximado das funções sen x e cos x a partir dos desenvolvimentos em série a seguir, considerando N termos do desenvolvimento em cada caso (o valor de x deverá ser fornecido em tempo de execução): x x x x (i) sen x x... 3! 5! 7! 9! x x x (ii) cos x ! 4! 6!

15 Referências Referência principal: (FORBELLONE e EBERSPÄCHER, 2005) FORBELLONE, A.L.V.; EBERSPÄCHER, H. F. Lógica de programação: a construção de algoritmos e estrutura de dados. 3. ed. São Paulo: Pearson Prentice Hall, Outras referências: (AGUILAR, 2008) AGUILAR, L. J. Fundamentos de programação: algoritmos, estruturas de dados e objetos. 3. ed. São Paulo: McGraw-Hill, (Ferrari e Cechinel, 2008) Ferrari, F.; Cechinel, C. Introdução a Algoritmos e Programação. Bagé: Universidade Federal do Pampa, Campus Bagé, (ASCENCIO e CAMPOS, 2007) ASCENCIO, A.F.G.; CAMPOS, E.A.V. Fundamentos da programação de computadores, Algoritmos, Pascal, C/C++ e Java. 2. ed. São Paulo: Pearson Prentice Hall, 2007 (HEHL, 1987) Hehl, M. E. Linguagem de Programação Estruturada FORTRAN 77. McGraw-Hill, (FARRER et. al., 1985) Farrer, H. & outros. Algoritmos Estruturados. Guanabara Dois, (FARRER et al., 1992) Farrer, H. & outros. FORTRAN Estruturado. Guanabara-Koogan S.A., 1992.