Captulo 4

Comandos de Repetio

No mundo real, comum a repetio de procedimentos para se realizar tarefas. Esses procedimentos no so repetidos eternamente, mas se encerram quando o objetivo atingido. Por exemplo, quando uma pessoa aperta um parafuso, ela gira a chave de fenda uma vez, duas vezes etc. at que o parafuso esteja apertado o suficiente. Durante esse processo, verificado, a cada volta, se o parafuso j est bem firme. Da mesma forma, podemos estruturar vrias atividades dirias como repetitivas. Durante a chamada feita por um professor, por exemplo, ele chama os nomes enquanto no terminar a lista. Outras repeties podem ser quantificadas com antecedncia. O aluno de castigo que precisa escrever 100 vezes no quadro negro: No vou fazer baguna nunca mais, executa a mesma instruo 100 vezes. Todas as repeties tm uma caracterstica comum: o fato de haver uma verificao de condio que pode ser representada por um valor lgico, para determinar se a repetio prossegue ou no. Essa a base para a implementao dos comandos de repetio em algoritmos. Em vez de fazermos um trabalho braal, escrevendo a mesma instruo vrias vezes, poderemos utilizar uma estrutura que indique que tal instruo ser executada quantas vezes for necessria.

4.1 Comando enquanto

Antes de vermos a sintaxe em nosso pseudocdigo, vejamos um exemplo do mundo real: o problema do elevador. Um elevador residencial tem um comportamento que pode ser descrito de forma algortmica. Vejamos o seu funcionamento: Na subida: sobe cada andar, verificando se est em um andar selecionado dentro do elevador. Isso feito at chegar ao andar mais alto selecionado dentro ou fora do elevador.

60

Captulo 4 Comandos de Repetio

enquanto no chegar ao andar mais alto selecionado interna/externamente faa incio suba um andar, incio

61

se o andar foi selecionado internamente ento pare,

abra as portas, fim fim

feche as portas,

Na descida: desce cada andar, verificando se est em um andar selecionado dentro ou fora do elevador. Isso feito at chegar ao andar mais baixo selecionado dentro ou fora do elevador
enquanto no chegar ao andar mais baixo selecionado interna/externamente faa incio desa um andar, se o andar foi selecionado interna/externamente ento incio pare, abra as portas, feche as portas, fim fim

O comando enquanto caracteriza-se por uma verificao de encerramento de atividades antes de se iniciar (ou reiniciar) a execuo de seu bloco de instrues. Dessa forma, no algoritmo do elevador, antes de subir/descer um andar verificado se o andar atual o mais alto/baixo selecionado. Caso no seja, um conjunto de atividades executado (sobe/desce um andar, verifica se um andar selecionado e abre (ou no) as portas). Vejamos sua sintaxe:
enquanto <valor booleano> faa <continuao do algoritmo> <bloco de instrues>

Voltemos ao exemplo do aluno de castigo. Fazer um algoritmo que escrevesse para ele, cem vezes, No vou fazer mais baguna, antes deste captulo, seria uma tarefa inglria. O algoritmo seria semelhante ao descrito a seguir. Algoritmo Lio_Aluno_Verso1
incio escreva(No escreva(No escreva(No escreva(No ... fim vou vou vou vou fazer fazer fazer fazer mais mais mais mais baguna!); baguna!); baguna!); baguna!);

{ O comando precisa ser escrito 100 vezes... }

62

Algoritmos e Programao

Para que possamos utilizar o comando de repetio, precisaremos verificar, de alguma forma, se o comando j foi executado 100 vezes.
enquanto <no foi executado 100 vezes o prximo bloco > faa escreva(No vou fazer mais baguna!);

Bem, o problema reside em implementar essa verificao. Uma estratgia muito comum para esse tipo de situao acompanhar a execuo das repeties contando cada vez que o bloco executado. Cada execuo do bloco de instrues chamada iterao. O prprio comando de repetio em conjunto com seu bloco de instrues conhecido como loop ou lao. Para que tenhamos a informao de quantas iteraes j foram realizadas no lao, necessitaremos de uma varivel que far o papel de contador. Essa varivel conter o nmero de iteraes j realizadas, sendo atualizada a cada nova iterao.

4.1.1 Problema 11 Escrever 100 vezes "No vou fazer mais baguna"
Faa um algoritmo que escreva 100 vezes o texto: No vou fazer mais baguna, utilizando um comando de repetio. Algoritmo Lio_Aluno_Verso2
var contador: inteiro; incio contador 0; incio { Nenhuma iterao foi feita at aqui } { O bloco ser repetido 100 vezes }

enquanto (contador < 100) faa

fim fim

contador contador + 1;

escreva(No vou fazer mais baguna!);

{ A cada iterao, conta-se mais 1 }

Vejamos a seguir outros exemplos.

4.1.2 Problema 12 Ler 100 nmeros e calcular a soma e a mdia

Faa um algoritmo que leia 100 nmeros e retorne a soma e a mdia desses valores. Algoritmo Soma_Mdia100
var contador: inteiro; incio valor, soma, mdia: real; contador 0; soma 0; { Nenhuma iterao foi feita at aqui }

1 2 3

enquanto (contador < 100) faa { O bloco ser repetido 100 vezes }

{ Ainda no foi somado nenhum valor }

Captulo 4 Comandos de Repetio

incio

63

4 5 6 7
fim

escreva(Entre com um valor: ); leia(valor); soma soma + valor;

contador contador + 1;

{ A cada iterao, conta-se mais 1 }

8 9 10
fim

escreva(Soma: , soma);

mdia soma / contador;

escreva(Mdia: , mdia);

interessante verificar o processo de acumulao de valores feito na varivel soma (linha 6). Seu valor atualizado a cada iterao, somando-se seu valor atual com o novo valor lido. Para que isso funcione, importante que o valor inicial da varivel seja definido antes da entrada do lao, para que um valor desconhecido no seja atribudo na primeira iterao do lao. Vejamos o teste de mesa para a melhor compreenso do processo. Para viabilizar a realizao do teste de mesa, consideremos o lao at 3 e no at 100, como est no algoritmo (Tabela 4.1). Entrada: 5, 4, 9 (ou seja, os valores que sero entrados pelo usurio sero 5, 4 e 9, nesta seqncia).

Tabela 4.1 Teste de mesa para Soma_Mdia100

Instruo 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 Linha contador valor soma mdia 1 0 ? ? ? 2 0 ? 0 ? 3 0 ? 0 ? 4 0 ? 0 ? 5 0 [5] 0 ? 6 0 5 5 ? 7 1 5 5 ? 3 1 5 5 ? 4 1 5 5 ? 5 1 [4] 5 ? 6 1 4 9 ? 7 2 4 9 ? 3 2 4 9 ? 4 2 4 9 ? 5 2 [9] 9 ? 6 2 9 18 ? 7 3 9 18 ? 3 8 9 10 3 3 3 3 9 9 9 9 18 18 {18} 18 ? 6 6 {6}

64

Algoritmos e Programao

Note que a condio de entrada/sada do lao est na linha 3. Esse teste executado nas instrues 3, 8, 13 e 18. Perceba tambm que o teste repetido sempre aps o bloco de instrues (linha 7) pertencente ao lao. Quando a condio verdadeira, a instruo a ser executada a do incio do bloco, na linha 4 (instrues 4, 9 e 14). Porm, na instruo 18, a condio falsa (no nosso teste, estamos considerando enquanto contador < 3) e a prxima instruo a ser executada (instruo 19) est na linha 8, aps o bloco de instrues pertencente ao comando enquanto.

Exerccio proposto
1. Adapte o algoritmo Soma_Mdia100 para que o nmero de valores a ser computado

seja determinado a partir de uma varivel de entrada e no como um valor fixo no programa, como fora definido.

4.1.3 Problema 13 Calcular a multiplicao de dois nmeros sem o operador "*"

Faa um algoritmo que calcule a multiplicao de dois nmeros inteiros sem utilizar o operador *. Em vez disso, utilize apenas o operador de adio +. Para implementar esse algoritmo, devemos lembrar que qualquer multiplicao pode ser expressa por meio de somas. Por exemplo, o resultado da expresso 6 * 3 o mesmo de 6 + 6 + 6 ou 3 + 3 + 3 + 3 + 3 + 3. Ou seja, soma-se um elemento com ele prprio o nmero de vezes do segundo elemento. Algoritmo Mult_Soma
var contador: inteiro; incio operando1, operando2, resultado, contador: inteiro; contador 0; { Nenhuma iterao foi feita at aqui }

1 2 3 4 5 6 7 8 9

escreva(Entre com o primeiro valor: ); leia(operando1); leia(operando2); incio escreva(Entre com o segundo valor: ); enquanto (contador < operando2) faa

resultado 0;

{ Ainda no foi somado nenhum valor }

{ O bloco ser repetido operando2 vezes }

resultado resultado + operando1; fim contador contador + 1;

{ A cada iterao, conta-se mais 1 }

10
fim

escreva(O resultado da multiplicao : ,resultado);

Exerccios propostos
1. Faa trs testes de mesa para o algoritmo anterior com as seguintes entradas: 0, 3; 3, 6 e 6, 3.

Captulo 4 Comandos de Repetio

65

2. Se voc fez o exerccio anterior, pode notar que o nmero de instrues a serem executadas para a segunda e a terceira entrada diferente, apesar de o resultado ser o mesmo. Isso porque sempre o operando1 ser somado e o operando2 determinar quantas vezes o lao ser repetido. Melhore o algoritmo para que o valor maior seja somado e o valor menor seja o determinante para o controle do lao, garantindo assim que o menor nmero de instrues seja executado para qualquer entrada, independentemente de sua ordem.

4.1.4 Problema 14 Calcular o fatorial de um nmero

Faa um algoritmo que leia um nmero inteiro e calcule o seu fatorial. Se o nmero for negativo, informe que o valor invlido. Sabemos que o fatorial de um nmero n, representado por n!, dado por: n * (n - 1) * (n - 2) *... * 1, para n > 0 e n! = 1 para n = 0 Como dito anteriormente, um ponto crucial para resolver um problema que inclua a repetio a definio do ponto de sada do lao. Alm disso, importante se definir a situao desejada para a entrada no lao e o que vai ser executado em cada iterao. Nesse problema, o lao s pode se iniciar aps a leitura do valor n e a verificao se tal valor vlido. Caso o valor seja 0, o fatorial deve ser retornado como 1 e o comando de repetio no precisa ser executado. A cada iterao dentro do lao, necessrio acumular o resultado da multiplicao do valor pelo subseqente (n * n - 1 *...). Tambm preciso subtrair 1 do ltimo valor que foi multiplicado, preparando-o para a prxima iterao ou para a sada do lao. A sada do lao feita quando o valor a ser multiplicado chegar a 1. Algoritmo Fatorial
var valor, fat, n: inteiro; incio escreva(Entre com um valor: ); leia(valor); se (valor < 0) ento escreva(Valor invlido!); seno incio fat 1; n valor; enquanto (n > 1) faa incio fat fat * n; n n 1; { A cada iterao, diminui-se 1 } fim escreva(O fatorial calculado : , fat); fim fim

66

Algoritmos e Programao

Note que o valor inicial de fat 1 e no 0, como se poderia imaginar. Isso porque o elemento neutro na multiplicao o 1 e no o 0, como na adio, ou seja, qualquer nmero multiplicado por 1 ele prprio, assim como acontece com o 0 em relao adio. O fatorial de 1 ou 0 calculado implicitamente, j que nesses casos o lao no executado, pois a condio de controle do lao (n > 1) no satisfeita nenhuma vez e o valor do fatorial permanece em 1, como esperado. Esta situao ilustra o fato de que o bloco de instrues pertencente ao lao pode no ser executado nenhuma vez, caso a condio de controle no seja satisfeita na primeira passagem.

Exerccio proposto
1. Faa dois testes de mesa referentes ao algoritmo Fatorial para o clculo do fatorial dos nmeros 1 e 5.

4.2 Comandos de repetio combinados com comandos de condio

A utilizao de comandos de repetio combinados com comandos de condio permite resolver problemas bem mais complexos que os vistos at agora. Na realidade, o ferramental j apresentado a base para toda a seqncia de algoritmos, e sua compreenso absolutamente fundamental para o desenvolvimento de algoritmos mais sofisticados. Os comandos de condio podem fazer parte de blocos pertencentes a comandos de repetio e vice-versa. Ou seja, estruturas como as descritas a seguir podem ocorrer intercaladas quantas vezes forem necessrias. Exemplo:
... se <valor booleano> ento incio ...

incio fim fim ...

enquanto <valor booleano> faa ...

seno incio ...

{ Fim do bloco se }

incio

enquanto <valor booleano> faa ...

incio fim

se <valor booleano> ento ....

seno

Captulo 4 Comandos de Repetio

incio fim fim fim fim ....

67

....

....

{ Fim do bloco enquanto } { Fim do bloco seno }

<continuao do algoritmo>

Na estrutura anterior temos comandos de deciso aninhados a comandos de repetio e vice-versa. Esse tipo de estrutura extremamente til para resolver problemas em diversas situaes. Vejamos a seguir alguns exemplos.

4.2.1 Problema 15 Calcular a soma dos nmeros mpares de um intervalo

Faa um algoritmo que calcule a soma de todos os nmeros mpares dentro de uma faixa de valores determinada pelo usurio. Um nmero mpar quando sua diviso por 2 no exata, ou seja, o resto resultante da diviso inteira do nmero por 2 tem valor 1. Vejamos como fica o cdigo:
se ((nmero resto 2) = 1) ento [seno ] <cdigo para nmero mpar>

<cdigo para nmero par>

Como o algoritmo solicita a soma dos valores mpares dentro de uma faixa, teremos que fazer o acmulo do resultado apenas quando a condio mpar for atendida. Essa condio ser testada para todos os nmeros dentro da faixa, por meio de um lao. Algoritmo Soma_mpares_Verso1
var inferior, superior, num, soma: inteiro; incio soma 0;

escreva(Entre com o limite inferior: ); leia(inferior); leia(superior); escreva(Entre com o limite superior: );

num inferior; incio

enquanto (num <= superior) faa se (num resto 2 = 1) ento num num + 1; soma soma + num;

fim fim

escreva(Somatrio: , soma);

68

Algoritmos e Programao

Exerccios propostos
1. Faa o teste de mesa com intervalo definido entre 4 e 13. 2. Adapte o algoritmo Soma_mpares_Verso1 para obrigar o usurio a entrar com um valor para o limite inferior menor que o valor definido para o limite superior. Para isso, faa um lao que garanta a entrada de um intervalo vlido (inferior < superior). 3. Adapte o algoritmo Soma_mpares_Verso1. Substitua o teste em que verificamos se o nmero mpar dentro do lao para, ento, acumul-lo varivel soma pela seqncia: a. Faa um nico teste antes do lao. b. Determine se o nmero mpar e considere como limite inferior o prximo mpar (ou o prprio nmero caso este seja mpar). c. Faa o lao aumentando 2 a 2 seu valor para que apenas os nmeros mpares sejam calculados, sem a necessidade de novas verificaes. 4. Faa o teste de mesa dos algoritmo Soma_mpares_Verso1 adaptado no exerccio proposto 3, considerando os limites 4 e 13. Compare o nmero de instrues executadas com o teste de mesa do algoritmo Soma_mpares_Verso1 (visto no exerccio 1).

4.2.2 Problema 16 Determinar se um nmero primo

Faa um algoritmo que leia um nmero inteiro positivo e determine se este primo ou no. Por definio, um nmero primo quando divisvel somente por si prprio e por 1. Portanto, para determinar se um nmero primo, temos de definir por quais nmeros divisvel. A aproximao mais simples, e que podemos dizer ser uma aproximao de fora bruta, poderia ser testar a divisibilidade do nmero avaliado por todos os nmeros menores que ele. Vejamos a implementao deste algoritmo. Algoritmo Primo_Verso1
var nmero, divisor: inteiro; { Variveis booleanas so teis para determinar a sada ou no de laos } incio leia(nmero); escreva(Entre com um nmero a ser testado: ); divisvel F; divisvel: booleano;

Captulo 4 Comandos de Repetio

enquanto (no(divisvel) e divisor > 1) faa incio se (nmero resto divisor = 0) ento seno fim divisvel V; divisor nmero 1;

69

divisor divisor 1;

se (no(divisvel)) ento seno fim

escreva(O nmero , nmero, primo.); escreva(O nmero , nmero, no primo.);

Apesar de o algoritmo Primo_Verso1 ser eficaz, visto que resolve o problema para o qual foi projetado, no se pode dizer que seja propriamente eficiente. Basta que analisemos com um pouco mais de profundidade que perceberemos que vrias otimizaes podem ser aplicadas ao raciocnio utilizado nesse algoritmo. Vejamos: 1. Nmeros pares (com exceo do 2) no podem ser primos, visto que so divisveis por 2. Se um nmero no for divisvel por 2, no ser divisvel por nenhum outro nmero par. Portanto, com exceo do nmero 2, s precisaremos testar nmeros mpares. 2. mais fcil que um nmero seja divisvel por um nmero pequeno do que por um nmero maior. Portanto, se iniciarmos a procura do divisor de baixo para cima, ao invs de cima para baixo, como foi implementado, teremos chance de encontrar o nmero muito antes. 3. Nenhum nmero pode ser divisvel por outro nmero maior que a metade dele. Portanto, no precisamos testar a divisibilidade dos nmero na faixa entre a metade e o prprio nmero. Se levarmos em conta tais consideraes, teremos um algoritmo muito mais eficiente que o anterior, pois executar muito menos instrues para responder a mesma questo. Algoritmo Primo_Verso2
var nmero, divisor: inteiro; incio divisvel: booleano;

leia(nmero);

escreva(Entre com um nmero a ser testado: ); divisvel F;

se (nmero resto 2 = 0 e nmero > 2) ento seno divisvel V; divisor 3;

{ Nmero par diferente de 2 }

{ Nmeros mpares menores que 6 so primos e no precisam entrar no lao }

enquanto (no(divisvel) e divisor <= nmero / 2) faa

{ Esta condio ser falsa se o nmero for par }

70
incio se (nmero resto divisor = 0) ento seno fim divisvel V;

Algoritmos e Programao

divisor divisor + 2;

{ Sero testados divisores mpares: 3, 5.. }

se (no(divisvel)) ento seno fim

escreva(O nmero , nmero, primo.); escreva(O nmero , nmero, no primo.);

Um raciocnio mais sofisticado pode ainda nos dar uma otimizao final. Vejamos alguns exemplos para facilitar a compreenso deste ponto: 15 divisvel pelos nmeros 1, 3, 5 e 15 (1 * 15, 3 * 5, 5 * 3 e 15 * 1). 16 divisvel pelos nmeros 1, 2, 4, 8 e 16 (1 * 16, 2 * 8, 4 * 4, 8 * 2 e 16 * 1). 17 divisvel pelos nmeros 1 e 17 (1 * 17, e 17 * 1). 20 divisvel pelos nmeros 1, 2, 4, 5, 10 e 20 (1 * 20, 2 * 10, 4 * 5, 5 * 4, 10 * 2 e 20 * 1). 25 divisvel pelo nmeros 1, 5 e 25 (1 * 25, 5 * 5 e 25 * 1). 36 divisvel pelo nmeros 1, 2, 3, 4, 6, 9, 12, 18 e 36 (1 * 36, 2 * 18, 3 * 12, 4 * 9, 6 * 6, 9 * 4, 12 * 3, 18 * 2 e 36 * 1). Os exemplos anteriores so para ilustrar a seguinte propriedade da divisibilidade de um nmero: qualquer nmero que seja divisvel por outro ter como divisores dois nmeros ou fatores, e um ser maior que o outro, a no ser que tais nmeros sejam iguais (quando o nmero tem uma raiz quadrada exata). No caso de divisores diferentes, o nmero menor sempre ser menor que a raiz quadrada do resultado da multiplicao e o nmero maior, maior que a raiz quadrada do nmero em questo. Podemos perceber que quanto maior um dos fatores, menor o outro. A relao se inverte aps a linha da raiz quadrada, quando os nmeros se repetem em ordem inversa. Podemos, ento, concluir que se um nmero no for divisvel por um nmero menor ou igual sua raiz quadrada, no ter outro divisor que no ele prprio ou o 1. Ou seja, ser um nmero primo. Portanto, s precisamos testar a divisibilidade de um nmero por valores iguais ou inferiores sua raiz quadrada. Adaptando o algoritmo, teremos o que se v no exemplo a seguir. Algoritmo Primo_Verso3
var nmero, divisor: inteiro; divisvel: booleano;

Captulo 4 Comandos de Repetio

incio escreva(Entre com um nmero a ser testado: ); leia(nmero); divisvel F; { Nmero par } se (nmero resto 2 = 0 e nmero > 2) ento divisvel V; seno divisor 3; enquanto (no(divisvel) e divisor <= nmero raiz 2) faa { Nmeros mpares menores que 9 so primos e no precisam entrar no lao } incio se (nmero resto divisor = 0) ento divisvel V; seno { Sero testados nmeros mpares: 3, 5, ... } divisor divisor + 2; fim se (no(divisvel)) ento escreva(O nmero , nmero, primo.); seno escreva(O nmero , nmero, no primo.); fim

71

Exerccio proposto
1. Faa dois testes de mesa referentes aos trs algoritmos que identificam um nmero primo. Verifique as seguintes entradas: 15 e 29. Verifique qual o nmero de instrues necessrio executar em cada uma delas e veja a diferena entre suas execues.

4.3 Comandos de repetio encadeados

Apesar de seguir o mesmo padro de encadeamento de outros comandos j vistos, a utilizao de comandos de repetio encadeados geralmente causa uma certa dificuldade para o seu acompanhamento primeira vista. A estrutura do algoritmo que contm laos encadeados segue:
<nome do algoritmo> <declarao de variveis> incio ... enquanto <valor booleano> faa incio ... enquanto <valor booleano> ento incio .... fim { Fim do bloco enquanto interno } .... fim { Fim do bloco enquanto externo } .... <continuao do algoritmo> fim

72

Algoritmos e Programao

De fato, podemos ter tantos laos encadeados quanto precisarmos. E ainda podemos t-los combinados com comandos de deciso e assim por diante. At agora, usamos os laos para fazer operaes sobre um conjunto de elementos. Por exemplo, no caso da soma dos nmeros primos, tnhamos que executar um bloco de condio para cada possvel divisor do nmero em questo. No caso da soma de 100 nmeros, os nmeros entrados eram acumulados dentro do lao, repetindo-se o processo para cada nmero. A utilizao de laos encadeados pode ser necessria quando precisamos fazer uma operao repetitiva para cada elemento dentro de um conjunto. Imaginemos que precisssemos calcular a mdia das notas de uma classe. At a, um nico lao seria suficiente. Porm, imaginemos agora que precisssemos calcular a mdia das notas de todas as turmas de uma escola. As turmas so um conjunto. As notas dos alunos dentro de cada turma so outro conjunto. Para cada conjunto, precisaramos de um lao, nesse caso, dois laos encadeados. E se precisssemos ainda fazer o clculo para todas as escolas de uma cidade. Nesse caso precisaramos de trs laos encadeados (escolas/turmas/alunos).

4.3.1 Problema 17 Calcular a mdia das turmas de uma escola

Faa um algoritmo que calcule a mdia de todas as turmas de uma escola. Considere como entradas o nmero de turmas e o nmero de alunos de cada turma. A mdia de cada turma deve ser apresentada, alm da mdia geral, que ser o resultado da mdia das turmas. Um detalhe importante de se notar na resoluo desse tipo de algoritmo o fato de os laos geralmente terem condies diferentes e independentes. Podemos at mesmo resolver um exerccio de cada vez, abstraindo um dos laos e se concentrando no segundo. Vejamos, ento, a soluo do problema para apenas uma turma, para depois resolvermos o problema de todas as turmas: Algoritmo Mdia_Turma
var cont, alunos: inteiro; incio nota, soma, mdia: real; cont 0; soma 0; { Nenhuma iterao foi feita at aqui }

1 2 3 4 5 6 7

escreva(Entre com o nmero de alunos); leia(alunos); incio enquanto (cont < alunos) faa

{ Ainda no foi somado nenhum valor }

{ Ser repetido para cada aluno da turma }

escreva(Entre com a nota do aluno: , cont + 1); leia(nota);

Captulo 4 Comandos de Repetio

8 9
fim soma soma + nota; cont cont + 1;

73

10 11
fim

escreva(A mdia da turma : , mdia);

mdia soma / alunos;

Agora, vamos resolver o que seria o clculo das mdias de uma escola, considerando que temos as mdias de cada turma j preparadas pelo usurio. Algoritmo Mdia_Escola_Verso1
var cont, turmas: inteiro; incio mdia_turma, soma, mdia_escola: real; cont 0; soma 0; { Nenhuma iterao foi feita at aqui }

1 2 3 4 5 6 7 8 9

escreva(Entre com o nmero de turmas: ); leia(turmas); incio enquanto (cont < turmas) faa

{ Ainda no foi somado nenhum valor }

{ Ser repetido para cada turma }

leia(mdia_turma); cont cont + 1;

escreva(Entre com a mdia da turma: , cont + 1);

soma soma + mdia_turma;

fim

10 11
fim

escreva(A mdia da escola : , mdia_escola);

mdia_escola soma / turmas;

Bem, resolvemos as duas partes do algoritmo. Entretanto, a parte da mdia das escolas conta com uma situao que no temos: a mdia de cada turma no conhecida de antemo pelo usurios, a no ser que estes executassem o primeiro algoritmo, anotassem num papel o resultado de cada turma e executassem o segundo algoritmo para passar esses valores. claro que esta soluo no razovel. De fato, o que precisa ser feito substituir o trecho do segundo algoritmo em que o usurio entra com as mdias das turmas pelo primeiro algoritmo, que quem calcula a mdia de cada turma. Ateno especial deve ser dada ao possvel conflito de variveis. Por exemplo, os contadores utilizados nos dois algoritmos tratam de elementos diferentes (alunos e turmas, respectivamente) e devem ser tratados como variveis independentes. Algoritmo Mdia_Escola_Verso2
var cont_a, alunos, cont_t, turmas: inteiro; nota, mdia_turma, soma_turma, mdia_escola, soma_escola: real;

74
incio

Algoritmos e Programao

1 2 3 4 5 6 7 8 9 10 11 12 13 14

cont_t 0;

escreva(Entre com o nmero de turmas: ); leia(turmas); incio enquanto (cont_t < turmas) faa { Ser repetido para cada turma da escola } cont_a 0; { O lao interno, da turma, em que cada aluno ser contado } soma_turma 0; leia(alunos); incio escreva(Entre com o nmero de alunos da turma , cont_t + 1); enquanto (cont_a < alunos) faa { Ser repetido p/ cada aluno da turma } escreva(Entre com a nota do aluno: , cont_a + 1); soma_turma soma_turma + nota; cont_a cont_a + 1;

soma_escola 0;

{ O lao externo, da escola, em que cada turma ser contada }

leia(nota);

fim

{ A cada iterao, mais um aluno }

15 16 17 18
fim

escreva(A mdia da turma , cont_t + 1, : , mdia_turma); soma_escola soma_escola + mdia_turma; cont_t cont_t + 1; { A cada iterao, mais uma turma }

mdia_turma soma_turma / alunos;

19 20
fim

escreva(A mdia da escola : , mdia_escola);

mdia_escola soma_escola / turmas;

Para facilitar o teste, acompanhemos o teste de mesa considerando uma escola com duas turmas com 3 e 2 alunos cada uma (Tabela 4.2).

Tabela 4.2 Teste de mesa para Mdia_Escola_Verso2

Instruo Linha cont_a alunos nota
1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 10 11 12 13 ? ? ? ? ? 0 0 0 0 0 {0} 0 0 ? ? ? ? ? ? ? ? [3] 3 3 3 3 ? ? ? ? ? ? ? ? ? ? ? [7,5] 7,5

cont_t turmas
0 0 0 0 0 0 0 {0} 0 0 0 0 0 ? ? ? [2] 2 2 2 2 2 2 2 2 2

mdia_ turma
? ? ? ? ? ? ? ? ? ? ? ? ?

soma_ mdia_ turma escola

? ? ? ? ? ? 0 0 0 0 0 0 7,5 ? ? ? ? ? ? ? ? ? ? ? ? ?

soma_ escola
? 0 0 0 0 0 0 0 0 0 0 0 0

10 11 12 13

Captulo 4 Comandos de Repetio

Instruo Linha cont_a alunos nota
14 14 10 11 12 13 14 10 11 12 13 14 10 15 16 17 18 5 6 7 8 9 10 11 12 13 14 10 11 12 13 14 10 15 16 17 18 5 19 20 1 1 {1} 1 1 2 2 {2} 2 2 3 3 3 3 3 3 3 0 0 0 0 0 {0} 0 0 1 1 {1} 1 1 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 [2] 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 7,5 7,5 7,5 [5] 5 5 5 5 [5,5] 5,5 5,5 5,5 5,5 5,5 5,5 5,5 5,5 5,5 5,5 5,5 5,5 5,5 5,5 [8] 8 8 8 8 [9] 9 9 9 9 9 9 9 9 9 9

75
cont_t turmas
0 0 0 0 0 0 0 0 0 0 0 0 0 {0} 0 1 1 1 1 {1} 1 1 1 1 1 1 1 1 1 1 1 1 1 {1} 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

mdia_ turma
? ? ? ? ? ? ? ? ? ? ? ? 6 {6} 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 8,5 {8,5} 8,5 8,5 8,5 8,5 8,5

soma_ mdia_ turma escola

7,5 7,5 7,5 7,5 12,5 12,5 12,5 12,5 12,5 18 18 18 18 18 18 18 18 18 0 0 0 0 0 0 8 8 8 8 8 17 17 17 17 17 17 17 17 17 17 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 7,25 {7,25}

soma_ escola
0 0 0 0 0 0 0 0 0 0 0 0 0 0 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 14,5 14,5 14,5 14,5 14,5

15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

76

Algoritmos e Programao

As linhas identificadas com E so relativas ao lao externo e as marcadas com I so relativas ao lao interno. Note que o nmero de instrues executadas bastante grande. Isto ocorre em virtude do encadeamento dos laos, mesmo tendo usado entradas pequenas (duas turmas com 3 e 2 alunos). Os custos computacionais de laos encadeados no desempenho de algoritmos sero analisados com mais detalhes no captulo 12.

Exerccio proposto
1. Faa um algoritmo que calcule a mdia de todas as escolas de uma cidade. Cada escola tem diversas turmas. Considere como entrada o nmero de escolas, o nmero de turmas de cada escola e o nmero de alunos de cada turma. A mdia de cada escola deve ser apresentada, alm da mdia geral, que ser o resultado da mdia de todas as escolas da cidade.

4.4 Comando repita

Alm do comando enquanto, existem outras estruturas para implementar laos repetitivos. O comando repita funciona de forma similar ao comando enquanto, exceto pelo fato de que a condio de controle s testada aps a execuo do bloco de comandos, e no antes, como o caso do comando enquanto. Vejamos sua sintaxe:
repita at <valor booleano>; <bloco de instrues>

<continuao do algoritmo>

Assim, podemos utilizar o comando repita sempre que tivermos certeza de que o bloco de instrues ser executado ao menos uma vez, sem a necessidade do teste na entrada do bloco. Vejamos um exemplo:

4.4.1 Problema 18 (adaptao do problema 15)

Faa um algoritmo que calcule a soma dos nmeros mpares entre 1 e um limite superior definido pelo usurio. Algoritmo Soma_mpares_Verso2
var superior, num, soma: inteiro; incio

1 2 3 4

escreva(Entre com o limite superior: ); leia(superior); num 1;

soma 0;

Captulo 4 Comandos de Repetio

repita incio

77

5 6 7
fim

se (num resto 2 > 0) ento num num + 1; soma soma + num;

8 9
fim

at (num > superior);

escreva(A soma dos nmeros mpares : , soma);

Pelo exemplo, podemos perceber que a condio do lao at (num > superior) diferente da similar no comando enquanto implementada no problema 15, enquanto (num <= superior). Isso ocorre porque, ao contrrio do comando enquanto, a sada de um lao repita ocorre quando a condio booleana se torna verdadeira. Nos laos enquanto, a sada do lao s ocorre quando a condio se torna falsa. Vejamos o teste de mesa considerando o limite superior como 4 (Tabela 4.3).

Tabela 4.3 Teste de mesa para Soma_mpares_Verso2

Instruo Linha num superior soma 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 1 2 3 4 5 6 7 8 5 7 8 5 6 7 8 5 7 8 9 ? ? ? 1 1 1 2 2 2 3 3 3 3 4 4 4 5 5 5 ? ? [4] 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 0 0 0 0 0 1 1 1 1 1 1 1 4 4 4 4 4 4 4

Notemos que a linha do comando repita no registrada na execuo. Isso ocorre porque na realidade o que executado apenas o teste de controle e o desvio do fluxo do algoritmo dependendo do resultado do teste.

78

Algoritmos e Programao

Exerccios propostos
1. Faa a multiplicao apenas por meio de somas (utilize o comando repita). 2. Faa um algoritmo que determine se um nmero primo (utilize o comando repita).

4.5 Comando para

Se analisarmos os exemplos de utilizao de laos, perceberemos que a maioria deles tem comportamento similar. Uma situao inicial, definida antes do incio do lao como uma preparao para a sua entrada, um teste de controle para a entrada/sada do bloco e uma instruo dentro do lao que, em algum momento, far com que a condio de controle seja atingida e o lao se encerre no momento oportuno. Vejamos um exemplo: Algoritmo Soma_mpares_Verso3
var inferior, superior, num, soma: inteiro; incio soma 0;

escreva(Entre com o limite superior: ); leia(superior); { Situao inicial, ou preparao para a entrada no lao } { Teste de entrada/sada }

num 1; incio

enquanto (num <= superior) faa se (num resto 2 > 0) ento num num + 1; soma soma + num;

{ Instruo utilizada para que a condio de controle seja atingida } fim fim

O comando para procura resumir essas trs caractersticas comuns maioria das implementaes de laos em uma s instruo, facilitando assim a construo tpica de laos. A sintaxe do comando para:
para (<instruo1 de preparao> [, <instruo2 de preparao> ...]; <condio1 de controle>[, <condio 2 de controle>...]; <passo para alcance da condio>) faa <continuao do algoritmo> <bloco de instrues>

Portanto, temos a separao do comando em trs clusulas: preparao, condio e passo.

Captulo 4 Comandos de Repetio

79

Vale citar que, quando temos mais de uma instruo de preparao (primeira clusula), estas so separadas por vrgula e executadas na ordem em que se encontram no comando. Quando temos mais de uma condio de controle (segunda clusula), os testes tambm so realizados em ordem, e a condio toda Verdadeira apenas se todas as condies o forem. Ou seja, equivalente a uma condio lgica ligada pelo conectivo e. No h como representar composio de condies ou no comando para. Nesse caso, deve-se obrigatoriamente fazer uso dos comandos enquanto ou repita. Algumas linguagens de programao no implementam explicitamente a terceira clusula (passo), e esta tem, nesses casos, um comportamento implcito sempre igual. No caso da linguagem Pascal, por exemplo, o passo sempre o incremento/decremento em 1 varivel preparada na primeira clusula. Nesses casos, em geral, o para usado quase que exclusivamente em algoritmos com contadores. J a linguagem de programao C implementa todas as clusulas do comando para. O comando para executado da seguinte maneira: 1. Execute a instruo de preparao na primeira iterao do lao. 2. Execute o teste de controle. Caso seja Verdadeiro, passe para o item 3. Caso contrrio, passe para o item 6. 3. Execute o bloco de instrues. 4. Execute o passo para alcance da condio de controle. 5. Passe para o item 2. 6. Saia do lao e prossiga o algoritmo. O comando para equivalente seguinte estrutura:
<instruo de preparao> incio enquanto (<teste de controle>) faa <instrues> fim <passo>

Implementemos novamente o algoritmo Soma_mpares_Verso1 utilizando o comando para em vez do comando enquanto: Algoritmo Soma_mpares_Verso4
var superior, num, soma: inteiro; incio

1 2

escreva(Entre com o limite superior: );

soma 0;

80
3 4 5 6 7
fim leia(superior);

Algoritmos e Programao

para (num 1; num <= superior; num num + 1) faa se (num resto 2 > 0) ento soma soma + num;

escreva(A soma dos nmeros mpares : , soma);

O bloco de instrues do comando para s contm uma instruo (o comando se) e, por isso, no precisa ser delimitado pelo incio/m. Vejamos o teste de mesa considerando o limite superior como 4 (Tabela 4.4).

Tabela 4.4 Teste de mesa para Soma_mpares_Verso4 Instruo Linha num superior soma
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 1 2 3 4 4 5 6 4 4 5 4 4 5 6 4 4 5 4 4 7 ? ? ? 1 1 1 1 2 2 2 3 3 3 3 4 4 4 5 5 5 ? ? [4] 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 0 0 0 0 0 0 1 1 1 1 1 1 1 4 4 4 4 4 4 {4} Passo Teste de entrada/sada Passo Teste de entrada/sada Passo Teste de entrada/sada Passo Teste de entrada/sada Instruo inicial Teste de entrada/sada

Comentrios

Perceba que o nmero de instrues executadas praticamente igual ao nmero de instrues executadas na implementao do mesmo algoritmo utilizando o comando repita apresentado na seo 4.4, apesar de o nmero de linhas do algoritmo ser diferente. Podemos notar que a linha 4 (do comando para) contm mais de uma instruo, sendo representada separadamente no teste de mesa. Isso porque o comando para uma construo diferente no que diz respeito apenas ao estilo de programao, mas internamente seu funcionamento igual ao do comando enquanto ou repita, e no h ganho de

Captulo 4 Comandos de Repetio

81

desempenho ou diminuio de instrues executadas pela sua utilizao. Temos apenas uma diminuio do nmero de linhas do algoritmo em virtude de seu estilo compacto, em que descrevemos trs instrues em apenas uma linha.

4.5.1 Problema 19 Calcular o somatrio

Faa um algoritmo que calcule a seguinte frmula:

i=3

(5 * i + 2)

em que n definido pelo usurio. Esse tipo de frmula encaixa-se perfeitamente na estrutura do comando para. Podemos separar: Instruo de preparao: i = 3 Condio de sada: i = n Passo: i
i + 1

Algoritmo Somatrio
var i, n, somat: inteiro; incio

1 2 3 4 5 6
fim

escreva(Entre com o limite superior: ); leia(n); somat 0;

para (i 3; i <= n; i i + 1) faa somat somat + (5 * i + 2);

escreva(O somatrio somat);

i=3

(5 * i + 2)

para o limite definido , n, ,

Exerccios propostos
1. Faa o teste de mesa para o algoritmo Somatrio. Faa os prximos algoritmos utilizando o comando para. 2. Faa a multiplicao apenas por meio de somas. 3. Faa um algoritmo que determine se um nmero primo.

82

Algoritmos e Programao

4.6 Exerccios do captulo

1. Da mesma forma que a multiplicao pode ser expressa como o resultado de vrias adies, a potenciao pode ser representada por uma srie de multiplicaes. Faa um algoritmo que calcule a potenciao utilizando o operador *. Depois, faa o teste de mesa para garantir que o exerccio est correto. 2. Considerando que a potenciao o resultado de vrias multiplicaes e que a multiplicao pode ser expressa por meio de adies, implemente um algoritmo que realize a potenciao apenas por meio de adies. 3. Faa um algoritmo que calcule a diviso inteira de dois nmeros, por exemplo, 10 div 3 = 3, utilizando o operador de adio ou subtrao. Depois, faa o teste de mesa para garantir que o exerccio est correto. Para auxiliar na resoluo deste exerccio, observe que a operao de diviso segue o raciocnio similar ao da multiplicao, porm de forma inversa. Ou seja, o nmero de vezes que se subtraindo o dividendo (operando1) pelo divisor (operando2) chegar a 0 o quociente procurado. Vejamos o exemplo: 12 div 3. Operando1: 12 Operando2: 3 Quociente: 4 Se calcularmos 12 - 3 - 3 - 3 - 3 = 0 (12 subtrado 4 vezes (quociente) por 3 igual a 0). Caso o quociente no seja exato, preciso verificar que a prxima subtrao ter um resultado negativo: 13 div 3 13 - 3 - 3 - 3 - 3 = 1. Subtraindo-se mais uma vez, teremos 2. Portanto, o resultado procurado 4. 4. Faa um algoritmo que calcule a soma dos nmeros primos entre 1 e 100. 5. Dada a definio de MDC: dados dois nmeros inteiros a e b no nulos, define-se o mximo divisor comum (MDC) como sendo o maior inteiro que divide simultaneamente a e b, faa um algoritmo que leia dois nmeros e, a partir deles, descubra o mximo divisor comum (MDC). 6. Dada a definio de MMC: dados dois nmeros inteiros a e b no nulos, define-se o mnimo mltiplo comum (MMC) como sendo o menor inteiro positivo, mltiplo comum de a e b, faa um algoritmo que leia dois nmeros e encontre o mnimo mltiplo comum (MMC). Esse algoritmo deve utilizar o seguinte mtodo para calcular o MMC: "multiplicar os dois nmeros e dividirpelo MDC (mximo divisor comum)".

Captulo 4 Comandos de Repetio

83

7. Faa um novo algoritmo para o clculo do MMC de dois nmeros, mas que em vez de utilizar a fatorao, parta do seguinte princpio: "o MMC o menor nmero maior ou igual ao maior dos dois nmeros escolhidos e que divisvel pelos dois nmeros iniciais." Portanto, parta do maior dos dois nmeros e verifique, dentro do lao, se o nmero o MMC testando sua divisibilidade pelos dois nmeros. 8. Otimize o algoritmo do exerccio 7 considerando que os nmeros candidatos ao MMC devem ser mltiplos do maior dos dois nmeros. Portanto, teste apenas seus mltiplos (somando no 1, mas o valor do maior dos dois nmeros), dentro do lao para encontrar o MMC. 9. Faa o algoritmo para a resoluo do somatrio a seguir, sendo n definido pelo usurio e maior que 5:

i=5

(2 * i2+ 5 * i + 1)

10. Faa um algoritmo que encontre o n-simo termo da srie de Fibonacci. A srie de Fibonacci dada por: fib(n) = fib(n - 1) + fib(n - 2) para n > 1; Para n = 0 e n = 1, o valor dado por definio: fib(0) = 0 e fib(1) = 1. Exemplos: fib(0) = 0 fib(1) = 1 fib(2) = fib(1) + fib(0) = 1 + 0 = 1 fib(3) = fib(2) + fib(1) = 1 + 1 = 2 fib(4) = fib(3) + fib(2) = 2 + 1 = 3 fib(5) = fib(4) + fib(3) = 3 + 2 = 5 fib(6) = fib(5) + fib(4) = 5 + 3 = 8

84

Algoritmos e Programao

4.7 Exemplos de programas em Pascal e C

A seguir, temos programas para facilitar a transio do pseudocdigo para linguagem de programao. Os programas escolhidos contm exemplos comentados dos conceitos e notaes introduzidos no captulo. Todo programa implementado tem o seu correspondente em pseudocdigo no apndice A ou no prprio corpo do livro.

4.7.1 Programas em Pascal

4.7.1.1 Encontrar o n-simo termo da srie de Fibonacci (exerccio 10)
Faa um algoritmo que encontre o n-simo termo da srie de Fibonacci. Para mais informaes sobre a srie de Fibonacci, veja o exerccio 10 na pgina 84.

Arquivo Cap_04_10.pas
program Fibonacci(Input, Output); var n, fib_menos_1, fib_menos_2, fib_N, i: integer; write('Digite n, para calcular o n-simo termo da srie de Fibonacci: '); { O conectivo 'or' corresponde ao conectivo 'ou' } if (n = 0) or (n = 1) then else fib_N := n readln(n);

begin

begin fib_menos_2 := 0; fib_menos_1 := 1; { penltimo valor } { ltimo valor }

{ O comando 'for' corresponde ao comando 'para'. { O comando a seguir equivale a 'para (i 2; i <= n; i i + 1)' } for i := 2 to n do begin Em Pascal, a clusula 'passo' implcita }

fib_N := fib_menos_1 + fib_menos_2; fib_menos_2 := fib_menos_1; fib_menos_1 := fib_N;

end; end.

end;

writeln('O n-simo termo da srie de Fibonacci : ', fib_N)

4.7.1.2 Ler 100 nmeros e retornar a soma e a mdia aritmtica desses valores (problema 12)
Faa um algoritmo que leia 100 nmeros e retorne a soma e a mdia aritmtica desses valores.

Captulo 4 Comandos de Repetio

85

Arquivo Cap_04_prob12.pas
program Soma_media_100(Input, Output); var contador: integer;

begin

soma, media, valor: real; contador := 0; soma := 0; valor := 0; { Nenhuma iterao feita at aqui }

{ Ainda no foi somado nenhum valor }

writeln('Digite 100 valores para calcular a mdia aritmtica.');

{ O comando 'while' corresponde ao comando 'enquanto' } while (contador < 100) do begin

write('Entre com um valor: '); readln(valor); soma := soma + valor;

media := soma / contador;

end;

contador := contador + 1;

{ A cada iterao conta-se mais um } { Calcula a mdia aritmtica }

writeln('Soma: ', soma:18:2);

end.

writeln('Mdia aritmtica: ', media:18:2);

4.7.1.3 Calcular a soma dos nmeros mpares entre 1 e um limite superior (problema 18)
Faa um algoritmo que calcule a soma dos nmeros mpares entre 1 e um limite superior definido pelo usurio.

Arquivo Cap_04_prob18.pas
program Soma_impares(Input, Output); var superior, num, soma: integer;

begin

soma := 0; { ainda no foi somado nenhum valor } write('Entre com o limite superior: '); readln(superior);

num := 1;

{ O comando 'repeat' corresponde ao comando 'repita'} repeat

{ Em Pascal, o repeat no precisa da definio explcita do incio/fim do bloco } if num mod 2 > 0 then num := num + 1;

soma := soma + num;

until (num > superior); end.

writeln('A soma dos nmeros mpares de 1 at ', superior, ' : ', soma);

86

Algoritmos e Programao

4.7.2 Programas em C
4.7.2.1 Encontrar o n-simo termo da srie de Fibonacci (exerccio 10)
Faa um algoritmo que encontre o n-simo termo da srie de Fibonacci. Para mais informaes sobre a srie de Fibonacci, veja o exerccio 10 na pgina 84.

Arquivo Cap_04_10.c
#include <stdio.h> int main() {

int n, fib_menos_1, fib_menos_2, fib_N, i; scanf("%d", &n); fib_N = n;

printf("Digite n, para calcular o n-simo termo da srie de Fibonacci.\n"); if (n == 0 || n == 1) else {

fib_menos_1 = 1;

fib_menos_2 = 0;

for (i = 2; i <= n; i++) {

/* O comando for corresponde ao comando "para" */

/* ltimo valor */

/* penltimo valor */

fib_N = fib_menos_1 + fib_menos_2; fib_menos_2 = fib_menos_1; fib_menos_1 = fib_N;

printf("O n-simo termo da srie de Fibonacci : %d \n", fib_N); return 0;

4.7.2.2 Ler 100 nmeros e retornar a soma e a mdia aritmtica desses valores (problema 12)
Faa um algoritmo que leia 100 nmeros e retorne a soma e a mdia aritmtica desses nmeros.

Arquivo Cap_04_prob12.c
#include <stdio.h> int main() { int contador; float soma, media, valor; contador = 0; /* nenhuma iterao feita at aqui */ soma = 0; /* ainda no foi somado nenhum valor */ valor = 0; printf("Digite 100 valores para calcular a mdia aritmtica.\n");

Captulo 4 Comandos de Repetio

while (contador < 100) { printf("Entre com um valor: "); scanf("%f", &valor); soma = soma + valor; contador = contador + 1; /* a cada iterao conta-se mais 1 */ } /* Calcula a mdia aritmtica */ media = soma / contador; printf("Soma: %f\n", soma); printf("Mdia: %f\n", media); return 0; }

87

4.7.2.3 Calcular a soma dos nmeros mpares entre 1 e um limite superior (problema 18)
Faa um algoritmo que calcule a soma dos nmeros mpares entre 1 e um limite superior definido pelo usurio.

Arquivo Captulo_04_prob18.c
#include <stdio.h> int main() { int superior, num, soma; soma = 0; /* ainda no foi somado nenhum valor */ printf("Entre com o limite superior.\n"); scanf("%d", &superior); num = 0; do /* O comando do/while faz a mesma funo do comando repita/at */ { num = num + 1; /* se o nmero mpar */ if (num % 2 > 0) soma = soma + num; } while (num <= superior); printf("A soma dos nmeros mpares de 1 at %d : %d\n", superior, soma); return 0; }