Estruturas de repetição com teste no início

Objetivos:
Descrever as estruturas de repetição com teste no início, apresentando exemplos de como elas podem ser utilizadas para permitirem que blocos de comandos sejam executados por uma quantidade indefinida de vezes, enquanto condições lógicas definidas para a repetição forem verdadeiras.
Recursos e materiais:
Última atualização:
15/06/2020
Aulas do capítulo:

Na última aula, aprendemos como utilizar as estruturas de seleção para permitirmos que nossos algoritmos sejam capazes de tomar decisões e selecionar os blocos de comandos a serem executados com base nos resultados de expressões lógicas. Continuando nossos estudos sobre lógica de programação, conheceremos agora as estruturas de repetição com teste no início, utilizadas quando precisamos executar uma mesma sequência de comandos repetidas vezes.

As estruturas de repetição com teste no início

As estruturas de repetição com teste no início, cuja sintaxe é mostrada abaixo, são utilizadas para repetirmos um bloco de comandos (ações de 1 a n) por uma quantidade indefinida de vezes, enquanto uma condição lógica for verdadeira.

enquanto (condição) faça
    ação 1;
    ação 2;
    …
    ação n;
fimenquanto;

Essas estruturas são iniciadas com o comando “enquanto (condição) faça”, sendo que a condição entre parênteses é implementada através das operações aritméticas, relacionais e lógicas. O fim da estrutura de repetição é determinado pelo comando “fimenquanto”, adicionado após a última ação a ser repetida. Ele é utilizado para que o algoritmo saiba quando retornar para a primeira linha e testar novamente a condição lógica, e também para que saiba para onde seguir quando a condição retornar um valor falso.

É importante notarmos que nas estruturas de repetição com teste no início, a condição lógica sempre é verificada antes da execução do bloco de comandos. Assim, caso a expressão lógica retorne um valor falso já no primeiro teste, as ações de 1 a n não chegarão a ser executadas.

Entendendo os laços de repetição com teste no início por um exemplo

Para que possamos entender o funcionamento das estruturas de repetição com teste no início, vejamos abaixo um exemplo de um pseudocódigo para ler o nome de um usuário e o imprimir 3 vezes na tela.

Programa para imprimir 3 vezes o nome de um usuário
1
inicio;
//Início do algoritmo
2
    caracter: nome[1…10];
//Declara variável nome
3
    inteiro: contador;
//Declara variável contador
4
    contador \leftarrow 1;
//Inicia o valor do contador
5
    escreva (“Informe o seu nome: “);
//Exibe a mensagem na tela
6
    leia (nome);
//Armazena a informação lida
7
    enquanto (contador<=3) faça
//Início do laço de repetição
8
        escreva (nome);
//Imprime o nome na tela
9
        contador \leftarrow contador + 1;
//Incrementa o contador
10
    fimenquanto;
//Fim do laço de repetição
11
fim.
//Fim do algoritmo

A execução desse algoritmo, linha por linha, é ilustrada na Tabela 1. Para controlarmos a quantidade de vezes em que o nome é impresso na tela, criamos uma variável chamada contador e a iniciamos com valor 1. A cada iteração, o algoritmo testa o resultado da condição lógica e, caso ela seja verdadeira, executa as linhas 8 e 9. Depois que o contador assume valor igual a 4, a condição lógica testada retorna um valor falso, fazendo com que o algoritmo saia da linha 7 e siga direto para a linha 11.

Simulando a execução do Algoritmo 1
Linha nome contador contador <= 3? Tela
1 Início do algoritmo
2
3
4 1
5 1 Insira o seu nome:
6 José 1 Insira o seu nome: José <ENTER>
7 José 1 Verdadeiro Insira o seu nome: José
8 José 1 Insira o seu nome: José
José
9 José 1+1 Insira o seu nome: José
José
7 José 1+1 Verdadeiro Insira o seu nome: José
José
8 José 1+1 Insira o seu nome: José
José
José
9 José 1+1+1 Insira o seu nome: José
José
José
7 José 1+1+1 Verdadeiro Insira o seu nome: José
José
José
8 José 1+1+1 Insira o seu nome: José
José
José
José
9 José 1+1+1+1 Insira o seu nome: José
José
José
José
7 José 1+1+1+1 Falso Insira o seu nome: José
José
José
José
11 Fim do algoritmo

Variando o número de repetições

Um segundo exemplo mostra como podemos fazer para que a quantidade de repetições do bloco de comandos possa variar. Dessa vez, o algoritmo foi desenvolvido para ler e calcular a soma de N números reais informados pelo usuário. O processo de soma é interrompido quando o número zero for informado.

Programa para calcular a soma de N números reais
1
inicio;
//Início do algoritmo
2
    real: num, soma;
//Declara as variáveis
3
    soma \leftarrow 0;
//Atribui valor à variável
4
    escreva (“Informe o número a ser somado: “);
//Exibe a mensagem na tela
5
    leia (num);
//Armazena a informação lida
6
    enquanto (num <> 0) faça
//Início do laço de repetição
7
        soma \leftarrow soma + num;
//Atualiza a soma
8
        escreva (“Informe o número a ser somado: “);
//Exibe a mensagem na tela
9
        leia (num);
//Armazena a informação lida
10
    fimenquanto;
//Fim do laço de repetição
11
    escreva (“A soma vale: “, soma);
//Exibe o resultado final
12
fim.
//Fim do algoritmo

Nesse pseudocódigo, podemos observar que a primeira leitura do número informado pelo usuário é realizada fora do laço de repetição. Isso acontece porque a condição lógica da estrutura de repetição com teste no início é verificada antes de executarmos o bloco de comandos que queremos repetir. Assim, caso as linhas 4 e 5 não existissem, a variável num não teria nenhum valor na primeira vez que a condição lógica fosse testada. Como consequência, a condição lógica poderia ser erroneamente interpretada como falsa, fazendo com que o algoritmo seguisse para o fim do laço de repetição.

A execução desse algoritmo é apresentada na Tabela 2 para uma situação hipotética em que o usuário informa os números 21, 13 e, finalmente, 0 para interromper o processo. Recomendamos que você faça suas próprias simulações para garantir que compreendeu o funcionamento dessa estrutura. Deixe nos comentários qualquer dúvida para que possamos lhe ajudar.

Simulando a execução do Algoritmo 2
Linha num soma num <> 0? Tela
1 Início do algoritmo
2
3 0
4 0 Informe o número a ser somado:
5 21 0 Informe o número a ser somado: 21 <ENTER>
6 21 0 Verdadeiro Informe o número a ser somado: 21
7 21 0+21 Informe o número a ser somado: 21
8 21 0+21 Informe o número a ser somado: 21
Informe o número a ser somado:
9 13 0+21 Informe o número a ser somado: 21
Informe o número a ser somado: 13 <ENTER>
6 13 0+21+13 Verdadeiro Informe o número a ser somado: 21
Informe o número a ser somado: 13
7 13 0+21+13 Informe o número a ser somado: 21
Informe o número a ser somado: 13
8 13 0+21+13 Informe o número a ser somado: 21
Informe o número a ser somado: 13
Informe o número a ser somado:
9 0 0+21+13 Informe o número a ser somado: 21
Informe o número a ser somado: 13
Informe o número a ser somado: 0 <ENTER>
6 0 0+21+13 Falso Informe o número a ser somado: 21
Informe o número a ser somado: 13
Informe o número a ser somado: 0
11 0 0+21+13 Falso Informe o número a ser somado: 21
Informe o número a ser somado: 13
Informe o número a ser somado: 0
A soma vale: 34
12 Fim do algoritmo

As vantagens das estruturas de repetição

Por fim, vejamos mais um exemplo que ilustra as principais vantagens das estruturas de repetição, com um algoritmo que lê um número inteiro N informado pelo usuário e calcula o valor H conforme a equação mostrada abaixo.

H = 1 + \dfrac{1}{2} + \dfrac{1}{3} + \dfrac{1}{4} + ... + \dfrac{1}{N}

Como o valor de N sempre dependerá da informação enviada pelo usuário, fica inviável implementarmos o cálculo de H escrevendo a Equação (1) manualmente. Além disso, mesmo que o valor de N fosse constante, ele poderia ser muito grande, criando dificuldades para escrevermos toda a expressão matemática. Já com o laço de repetição com teste no início, o algoritmo fica resumido e limpo, facilitando sua compreensão. Fica também como sugestão para você leitor, simular a execução desse pseudocódigo.

Programa para calcular o valor de H
1
inicio;
//Início do algoritmo
2
    real: H;
//Declara as variáveis
3
    inteiro: den, N;
//Declara as variáveis
4
    H \leftarrow 0;
//Inicia o valor das variáveis
5
    den \leftarrow 1;
//Inicia o valor das variáveis
6
    escreva (“Informe o valor de N: “);
//Exibe a mensagem na tela
7
    leia (N);
//Armazena a informação enviada
8
    enquanto (den <= N) faça
//Início do laço de repetição
9
        H \leftarrow H + 1/den;
//Calcula H
10
        den \leftarrow den + 1;
//Atualiza o denominador
11
    fimenquanto;
//Fim do laço de repetição
12
    escreva (“O número H vale: “, H);
//Exibe o resultado final
13
fim.
//Fim do algoritmo

As estruturas de repetição com teste no início não são a única alternativa que temos para implementarmos laços em nossos algoritmos. Nas próximas aulas conheceremos as estruturas de repetição com teste no final e com variável de controle. Se você quer aprender tudo sobre esses e outros assuntos ligados à programação, acesse esse link e faça parte do nosso time. Uma comunidade interessada em Mecatrônica e pronta para ajudar no seu crescimento te espera. Quem deixaria passar essa oportunidade?

Referências bibliográficas

A. A. T. Maia, “Fundamentos da Computação – Algoritmos – Programação em Linguagem C”. Universidade Federal de Minas Gerais, 2013.

Deixe um comentário

%d blogueiros gostam disto: