MC102
Algoritmos e Programação de Computadores
Parte V


Norton Trevisan Roman




O COMANDO FOR

Lembra de nosso procedimento para desenhar um quadrado na tela? Lembra como fazíamos para desenhar dois? Nós

1. desenhávamos um quadrado
2. dávamos uma linha em branco
3. desenhávamos outro quadrado
4. dávamos outra linha em branco
Ou seja, nós fazíamos o seguinte programa:
    PROGRAM quadrados;

    PROCEDURE um_quad;
      {aqui ía o corpo do procedimento}

    BEGIN
      um_quad;
      writeln;
      um_quad;
      writeln;
    END.

Mas e se quiséssemos desenhar 10 triângulos? Teríamos de escrever 10 vezes um_quad; e 10 vezes writeln;. Nossa! Isso não parece certo. Não seria mais fácil ter um algoritmo assim?:

1. faça 10 vezes:
1.1 desenhe um quadrado
1.2 dê uma linha em branco
Ou seja, estaríamos dizendo uma só vez "desenhe 10 quadrados" em vez de dizer 10 vezes "desenhe um quadrado".

Como fazemos isso em Pascal? Usando FOR:

    FOR cont:=1 TO 10 DO
    BEGIN
      um_quad;
      writeln;
    END;

E se quisermos um número de quadrados diferente de 10? Basta substituir o 10 por esse número.

Reparou na variável cont? Ela é INTEGER, não esqueça de declará-la no VAR.

Mas afinal, o que o FOR faz? Vamos ler o comando:

    FOR cont:=1 TO 10 DO algo

Ou seja, "para cont valendo inicialmente 1 até 10 faça algo. Peraí, cont só recebeu 1. Como seu valor pode chegar a 10? é que, a cada repetição, o comando for incrementa cont, ou seja, soma 1 a cont. Assim, ele executa isso 10 vezes, pois após 10 vezes somar 1 a cont, esse chegará a ter 10 (se teve 1 como valor inicial).

Então, o for age assim:

1. atribui um valor inicial a cont
2. verifica se esse valor é menor ou igual ao limite 10
3. se for:
3.1. executa o corpo do for (o que está entre o begin e o end)
3.2. faz cont := cont + 1
4. se não for:
4.1. sai do for
5. volta a 2.
Agora repare que poderíamos por o writeln dentro do procediemtno um_quad. Façamos:
    PROCEDURE um_quad;
    BEGIN
      writeln('****');
      writeln('*  *');
      writeln('*  *');
      writeln('****');
      writeln
    END;

Mas, e nesse caso, como usaríamos o for? simples: 

    FOR cont:=1 TO 10 DO
    BEGIN
      um_quad
    END;

Somente assim? Não. Há um outro modo: como o corpo do FOR (o que está entre BEGIN e END) contém um só comando, podemos fazer assim:

    FOR cont:=1 TO 10 DO um_quad;

Economizamos duas linhas de escrita!

Atenção! Não confunda! Se dentro do for você quiser mais de um comando, deve colocar esses comandos entre BEGIN e END. Por exemplo:

    FOR cont:=1 TO 10 DO
      um_quad;
      writeln('quad');

O que isso faz? Não deixe a edentação te enganar, isso é o mesmo que:

    FOR cont:=1 TO 10 DO um_quad;
    writeln('quad');

Ou seja, isso desenha 10 quadrados dando uma linha em branco após cada um e então escreve 'quad'. Se quisermos escrever quad 10 vezes temos que fazer assim:

    FOR cont:=1 TO 10 DO
    BEGIN
      um_quad;
      writeln('quad');
    END;

Então, eis o programa completo:

    PROGRAM quad;
    VAR cont : integer;

    PROCEDURE um_quad;
    BEGIN
      writeln('****');
      writeln('*  *');
      writeln('*  *');
      writeln('****');
      writeln;
    END;

    BEGIN
      FOR cont:=1 TO 10 DO um_quad
    END

Poderíamos também por tudo isso no procedimento. Veja onde foi posta agora a declaração da variável:

    PROGRAM quad;

    PROCEDURE dez_quad;
    VAR cont : integer;
    BEGIN
      FOR cont:=1 TO 10 DO
      BEGIN
        writeln('****');
        writeln('*  *');
        writeln('*  *');
        writeln('****');
        writeln
      END
    END;

    BEGIN
      dez_quad
    END.



ITERAÇÃO

Suponha, agora, que queremos contar os quadrados desenhados. Então, queremos que a saída seja:

    quad 1
    ****
    *  *
    *  *
    ****

    quad 2
    ****
    *  *
    *  *
    ****
     .
     .
     .

    quad 10
    ****
    *  *
    *  *
    ****

Como fazemos? Podemos usar a variável cont. Para isso: 

    BEGIN
      FOR cont:=1 TO 10 DO
      BEGIN
        writeln('quad ',cont);
        um_quad
      END
    END.

Lembra que o for incrementava cont? Pois é. Podemos usar esse fator a nosso favor. Vejamos outro exemplo. Vamos imprimir os 10 primeiros pares:

    FOR cont:=1 TO 10 DO writeln(2*cont);

E a saída é: 

    2
    4
    6
    ...
    20

E agora os 10 primeiros ímpares:

    FOR cont := 1 to 10 do writeln(2*cont -1);

E teremos:

    1
    3
    5
    ...
    19

Agora vejamos alguns exemplos (estude-os cuidadosamente, vendo a importância de comentar o código. Fica mais claro não?):

1. Soma dos 100 primeiros inteiros

    VAR soma : integer; {soma dos números}
        cont : integer; {contador do for}
    BEGIN
      soma := 0; {inicializei a soma}
      FOR cont := 1 to 100 do
        soma := soma + cont; {vou somando os números}
      writeln(soma);
    END.

2. Soma dos termos de uma P.A.

    VAR soma  : integer; {a soma dos termos}
        razao : integer; {a razão da PA} 
        cont  : integer; {contador do FOR}
        termo : integer; {cada termo da PA} 
    BEGIN
      soma := 0;  {inicializando a soma}
      razao := 3; {a razão da PA é 3}
      termo := 1; {primeiro termo da PA}
      FOR cont:=1 TO 10 DO
      BEGIN
        soma := soma + termo;  {adiciono o termo anterior à soma}
        termo := termo + razão {calculo o próximo termo da PA}
      END;
      writeln('A soma de ',cont,' termos da PA de razão ',razao,' com início em 1 é ',soma)
    END.

Vamos ver agora o conteúdo de cada variável após cada iteração:

    cont   soma   termo
      -      0       1
      1      1       4
      2      5       7
      3     12      10
      4     22      13
      5     35      16
      6     51      19
      7     70      22
      8     92      25
      9    117      28
     10    145      31

     A soma de 10 termos da PA de razao 3 com início em 1 é 145




‹— Parte IV — Página da disciplina — Parte VI —›