Olá, caro(a) aluno(a), na aula passada, você aprendeu como criar estruturas condicionais que permitem alterar o fluxo de execução de um programa. Nesta lição, estudará como construir uma estrutura de repetição.

Em algumas situações, precisamos repetir diversas vezes a mesma porção de código para não ter que ficar reescrevendo trechos idênticos de código, assim, utilizamos os chamados laços de repetição. Um laço permite declarar uma condição que define quantas vezes um mesmo código deve ser repetido, de forma a eliminar a necessidade de reescrever diversas vezes o mesmo código.

Existem, basicamente, dois tipos de laços de repetição, os condicionais e os contados. Nesta aula, exploraremos o primeiro tipo, que consiste em laços em que é necessário declarar uma condição que, enquanto ela é verdadeira, o laço é executado.

Estruturas de repetição ou laços de repetição são definidos como blocos que executam linhas de código ou rotinas, repetidamente, de acordo com uma condição ou número de iterações. O código dentro do bloco é repetido até que a condição seja atendida, ou o número de iterações seja satisfeito.

Laços de repetição permitem automatizar métodos que seriam executados, manualmente, diversas vezes. Como vimos durante as nossas aulas, devemos sempre criar códigos da forma mais simples possível, isto é, com o mínimo de linhas e repetição de instruções, pois quanto mais linhas repetidas um código apresenta mais complicado será de outro programador compreender o objetivo do algoritmo. Como define Lopes e Garcia (2002), a vantagem das estruturas de repetição é que não é necessário reescrever trechos idênticos de código, reduzindo, de forma significativa, o tamanho do algoritmo.

Por meio da utilização de laços de repetição, é possível criar algoritmos que percorrem estruturas de dados analisando cada elemento, individualmente. Por exemplo, imagine que temos uma sequência de número e queremos encontrar um número específico, e, para realizar esta tarefa, é necessário passar por todos os números da sequência e comparar com o número que desejamos encontrar, para fazer essa tarefa, um laço de repetição é ideal.

Conforme formos avançando em nossos estudos nas bases da computação, você perceberá como muitas das estruturas que utilizaremos são criadas a partir das estruturas básicas da computação, como as estruturas condicionais e os laços.

Imagine os seguintes cenários: você está programando um software e deseja que o algoritmo escreva na tela “olá” 50 vezes, ou está criando um algoritmo que soma os 50 primeiros números pares. Sem um laço de repetição, você teria que modificar, manualmente, as instruções, isto é, para o primeiro exemplo, escrever o trecho de código do “olá” 50 vezes, de modo que teríamos 50 linhas de código que fazem a mesma coisa.  Em vez disso, podemos utilizar uma estrutura de loop para executar o código que escreve “olá” em determinado número de vezes.

Nesta lição, exploraremos os laços condicionais, utilizamos esta categoria quando não sabemos, previamente, quantas vezes que determinado código deve ser repetido.

A primeira estrutura de repetição que veremos é o ENQUANTO. Esta estrutura diz ao computador para fazer algo desde que uma condição seja atendida. Um loop enquanto consiste em uma condição e um bloco de código. A condição é avaliada e, se a condição for verdadeira, o código dentro do bloco é executado. Isso se repete até que a condição se torne falsa. Observe a sintaxe da estrutura enquanto:

Iniciamos o bloco com a palavra reservada ENQUANTO, em seguida devemos definir a condição seguida pela palavra FAÇA. Então, definimos o código que deverá ser repetido, e, por fim, fechamos o bloco com a palavra reservada FIM_ENQUANTO.

A Figura 1 apresenta o fluxograma de um laço enquanto o algoritmo inicial e, então, uma condição é verificada, enquanto a condição for avaliada como verdadeira, a rotina é executada em loop, quando a condição for avaliada como falsa, saímos do loop e, então, a execução é finalizada.

Construiremos um algoritmo que solicita ao usuário que digite um número, e que a sua execução só finalize quando o usuário digitar zero.

Objetivos: ler números digitados pelo usuário.

Entrada: ler números inteiros até que o usuário digite número zero.

Saída: imprimir os números digitados pelo usuário.

Vamos analisar linha a linha:

• Linhas 1 e 2: temos a abertura do bloco de declaração de variáveis, onde instanciamos 1 variável num do tipo inteiro, que receberá o valor digitado pelo usuário.

• Linha 3:  abertura do bloco do algoritmo.

• Linha 4: inicializamos a variável num com o valor 1.

• Linha 5:  abertura do bloco do laço de repetição ENQUANTO, aqui, declaramos a nossa condição de parada do laço (num != 0), isso é, o laço só parará de ser executado caso o número digitado pelo usuário seja 0, caso contrário, o laço continuará repetindo os comandos dentro dele.

• Linha 6: adicionamos o comando ESCREVA dentro do bloco ENQUANTO, este comando será executado até que a condição do laço deixe de ser satisfeita.

• Linha 7: armazenamos o valor digitado pelo usuário na variável num.

• Linha 8: apresentamos, na tela, o número digitado pelo usuário.

• Linha 9: fim do bloco enquanto.

• Linha 10: fim do algoritmo.

Dentro dos blocos de laço de repetição, podemos adicionar qualquer outra estrutura, por exemplo podemos adicionar uma estrutura condicional. Vejamos outros exemplos de aplicação do laço.

Vamos adaptar o código apresentado anteriormente para que, agora, ele conte quantas vezes o usuário digitou um número dentro de intervalo de 50 e 100.

Objetivo: ler vários números e apresentar quantos dos números digitados estão dentro do intervalo de 50 e 100.

Entrada: ler números inteiros até que o usuário digite número zero.

Processamento: contar quantos números foram digitados dentro do intervalo.

Saída: exibir, na tela, o total dos números digitados dentro do intervalo.

Vamos analisar linha a linha:

• Linhas 1 e 2: temos a abertura do bloco de declaração de variáveis, onde instanciamos 2 variáveis num, cont do tipo inteiro que receberá o valor digitado pelo usuário.

• Linha 3:  abertura do bloco do algoritmo.

• Linha 4: inicializamos a variável num com o valor 1.

• Linha 5: inicializamos a variável contadora cont  com zero, pois ainda nenhum número foi digitado.

• Linha 6:  abertura do bloco do laço de repetição ENQUANTO, aqui, declaramos a nossa condição de parada do laço (num != 0), isso é, o laço só parará de ser executado caso o número que o usuário digitar seja 0. Caso contrário, o laço continuará repetindo os comandos dentro dele.

• Linha 7: adicionamos o comando ESCREVA dentro do bloco ENQUANTO, e esse comando será executado até que a condição do laço deixe de ser satisfeita.

• Linha 8: armazenamos o valor digitado pelo usuário na variável num.

• Linha 9: início do bloco SE que será responsável por verificar se o número digitado pelo usuário está entre o intervalo de 50 e 100. O código dentro do bloco SE só será executado se o número que o usuário digitou for maior ou igual a 50 e menor ou igual a 100.

• Linha 10: Se a condição for satisfeita, incrementamos o contador em 1, pois um número dentro do intervalo foi digitado.

• Linha 11: fim do bloco SE.

• Linha 12: fim do bloco ENQUANTO.

• Linha 13: após sair do laço de repetição, apresentamos, na tela, o número de vezes que foram digitados números entre o intervalo definido.

• Linha 14: fim do algoritmo.

 A estrutura “repita” é outro laço de repetição condicional. Esta estrutura funciona de forma semelhante ao ENQUANTO, entretanto ela garante que o código dentro do bloco de repetição seja executado, pelo menos, uma vez antes de verificar a condição. Esse comportamento se deve pelo fato de a análise da condicional ser realizado apenas no final do bloco, como você pode observar na sintaxe do comando: 

Observe, primeiro definimos o que deve ser feito e só depois declaramos a condição de parada do laço, desta forma a primeira execução do laço é realizada sem a verificação da condição.

Vamos observar o código anterior, porém, agora, utilizando a estrutura REPITA.

Só alteramos as linhas 18, 20 e 26. Note que, ao executar o nosso algoritmo com a estrutura repita, não precisamos inicializar a variável num com o valor 1. Isso porque a condição de num ser diferente de zero será verificada apenas no final da execução do bloco repita, de forma que as linhas 21, 22, 23, 24 e 25 serão executadas a primeira vez, independentemente do valor armazenado em num.

Se a condição for “verdadeira”, o loop se repete. Assim, o código no loop é executado, pelo menos, uma vez. Mas observar que o fato de a verificação da condição ocorrer no final pode, em algumas situações, gerar um resultado diferente do que quando utilizamos a estrutura ENQUANTO.

Por exemplo, no código que estudamos durante toda esta aula, no algoritmo utilizando a estrutura, enquanto precisamos inicializar a variável num com 1 para forçar a entrada no laço, pois, se não colocarmos um número diferente de 0 na variável num, o bloco sequer será executado, porque a condição será satisfeita. Por outro lado, no laço repita não precisamos inicializar a variável, pois independentemente do valor armazenado nela, o bloco será executado, pelo menos, uma vez.

Nesta lição, estudamos a utilização de laços de repetição para realizar tarefas que não possuem um número específico de vezes que precisa ser executado. Vimos como aplicar os laços condicionais Enquanto e Repita.

Você deve ter notado que estas estruturas são muito flexíveis e que o mesmo problema pode ser resolvido com qualquer uma das duas estruturas apresentadas, porém, é necessário prestar atenção em alguns detalhes da implementação para não correr o risco de entrar em um loop infinito.

Que tal colocar em prática os conhecimentos adquiridos nesta aula? Construa um algoritmo que receba números inteiros e exiba, na tela, quantos números pares e quantos números ímpares foram digitados.

Objetivo: ler número digitados pelo usuário e identificar quais são pares e quais são ímpares

Entrada: números inteiros informados pelo usuário.

Processamento: verificar quantos números pares e ímpares foram digitados até o usuário digitar zero para sair do programa.

Saída: imprimir o número de valores pares.

1. VARIAVEIS

2.    num, cont: inteiro

3. INICIO

5. cont <- 0

6. REPITA

7.            ESCREVA(“Digite um número:")

8.            LEIA (num)

9.            SE (num % 2 == 0) ENTÃO

10.                   cont <- cont + 1

11.             FIM_SE

12.   ATÉ_QUE (num != 0)

13.    ESCREVA (“Foram digitados ”, cont, "números pares”)

14.   FIM