^[1]Copyright © 2026 Alyce Suza.

O laço enquanto, Contadores e Acumuladores

8.1 Por que Precisamos de Repetição?

Imagine calcular a média escolar de trinta alunos sem utilizar ciclos automáticos de repetição. Você precisaria escrever mecanicamente trinta comandos de leitura individuais e trinta operações de soma sequenciais no código fonte do seu sistema. Esse cenário braçal é impraticável para turmas pequenas e absolutamente impossível caso o banco de dados exija o processamento de mil alunos cadastrados. As estruturas de repetição, tecnicamente conhecidas na literatura computacional como loops, resolvem esse gargalo de processamento de forma matemática e definitiva, permitindo que a máquina assuma o volume massivo de trabalho sem esgotar o programador.

8.2 O Laço enquanto: Pré-Testado

O comando enquanto verifica a condição lógica obrigatoriamente antes de executar o bloco de instruções pela primeira vez. Se a condição inicial já for avaliada como falsa logo na largada do sistema, o computador ignora o bloco inteiro e o código interno nunca chega a ser executado. É por esta característica técnica e comportamental que ele é formalmente chamado de laço pré-testado em ciência da computação.

enquanto (condicao)
{
    // conjunto de instrucoes repetidas ciclicamente enquanto a condicao for VERDADEIRA
}

O exemplo abaixo demonstra a estrutura básica construindo um contador sequencial clássico que vai da unidade um até a dezena.

programa
{
    funcao inicio()
    {
        inteiro contador = 1    // declaracao da variavel de controle do ciclo

        enquanto (contador <= 10)
        {
            escreva(contador, " ")
            contador++    // ETAPA ESSENCIAL: atualiza a variavel de controle no laco
        }
        escreva("\nProcessamento finalizado!\n")
    }
}

Para compreender perfeitamente a mecânica invisível da máquina durante a execução de um loop, precisamos isolar o rastreamento lógico da memória passo a passo.

O controle do ciclo não se limita a somas progressivas. Você pode inverter a mecânica lógica e criar um laço perfeitamente regressivo utilizando o operador de decremento matemático.

programa
{
    funcao inicio()
    {
        inteiro i = 10

        enquanto (i >= 1)
        {
            escreva(i, " ")
            i--    // executa o decremento removendo unidades de 10 para 1
        }
        escreva("\nLancamento de foguete autorizado!\n")
    }
}

Também é plenamente viável controlar o passo da variável alterando o valor do incremento, saltando casas numéricas para processar apenas números pares no intervalo.

programa
{
    funcao inicio()
    {
        inteiro n = 2

        escreva("Registro de pares ate o limite de 20: ")
        enquanto (n <= 20)
        {
            escreva(n, " ")
            n = n + 2    // incrementa estritamente de 2 em 2 filtrando so os pares
        }
    }
}

8.3 Contadores: Contando Ocorrências

Um contador é uma variável dedicada de controle que aumenta ou diminui o seu valor numérico em uma unidade exata a cada vez que uma condição específica é atendida por dentro do ciclo de repetição. É evidente para quem sente na pele a depuração frustrante de algoritmos que esquecer de inicializar o contador com o valor zero antes da engrenagem do loop começar gera resultados fantasmas e cálculos completamente corrompidos pela sujeira residual da memória.

programa
{
    funcao inicio()
    {
        inteiro numero, contador = 0
        inteiro positivos = 0, negativos = 0, zeros = 0

        inteiro i = 0
        enquanto (i < 10)
        {
            escreva("Insira o Numero de indice ", i+1, ": ") leia(numero)

            se (numero > 0) { positivos++ }
            senao se (numero < 0) { negativos++ }
            senao { zeros++ }

            contador++
            i++
        }

        escreva("\nContagem de Positivos confirmados: ", positivos, "\n")
        escreva("Contagem de Negativos confirmados: ", negativos, "\n")
        escreva("Contagem de Zeros exatos: ", zeros, "\n")
    }
}

8.4 Acumuladores: Somando Valores

Diferente do contador que atua apenas adicionando unidades fixas para rastrear ocorrências, um acumulador trabalha de forma mais complexa somando valores numéricos variáveis e volumosos ao longo de todas as iterações rodadas do loop. Ele funciona conceitualmente como uma grande caixa registradora de mercado que vai guardando fielmente o valor progressivo e cumulativo das operações em andamento.

programa
{
    funcao inicio()
    {
        real nota, soma = 0    // acumulador obrigatoriamente inicializado com zero
        inteiro i = 1

        enquanto (i <= 5)
        {
            escreva("Registre a Nota ", i, " da avaliacao: ") leia(nota)
            soma = soma + nota    // ACUMULA adicionando o novo valor ao montante total
            i++
        }

        real media = soma / 5
        escreva("Soma total apurada no semestre: ", soma, "\n")
        escreva("Media escolar calculada globalmente: ", media, "\n")
    }
}

8.5 Loops com Sentinela

Um valor sentinela é uma chave numérica especial e predefinida que o usuário digita no console exclusivamente para sinalizar ao sistema computacional que ele deseja interromper a inserção contínua de dados na memória. Essa estratégia arquitetural é vital quando não sabemos de forma antecipada o número exato de repetições que o programa vai exigir, delegando ao operador humano o poder absoluto de encerrar a rotina no momento adequado.

programa
{
    funcao inicio()
    {
        real nota, soma = 0
        inteiro contador = 0

        escreva("Digite notas sequenciais e insira -1 para finalizar a operacao:\n")
        escreva("Nota do aluno: ") leia(nota)

        enquanto (nota != -1)    // o valor -1 assume o papel tecnico de sentinela
        {
            soma = soma + nota
            contador++
            escreva("Nota do aluno: ") leia(nota)
        }

        se (contador > 0)
        {
            escreva("Volume de Notas efetivamente digitadas: ", contador, "\n")
            escreva("Media final da instituicao: ", soma / contador, "\n")
        }
        senao
        {
            escreva("Nenhuma nota letiva foi digitada na sessao de uso.\n")
        }
    }
}

8.6 Exercícios do Capítulo 8

Gabarito do Capítulo 8

programa
{
    funcao inicio()
    {
        inteiro n = 1, cont = 0
        real soma = 0
        
        enquanto (n <= 100)
        {
            se (n % 2 != 0)
            {
                escreva(n, " ")
                cont++
                soma = soma + n
            }
            n++
        }
        escreva("\nFechamento Total de indices apurados: ", cont, " | Soma macica consolidada: ", soma, "\n")
    }
}

programa
{
    funcao inicio()
    {
        real n, soma = 0, maior, menor
        inteiro cont = 0
        
        escreva("Digite um Numero valido ou use 0 como chave sentinela de parada: ") leia(n)
        
        se (n == 0) { escreva("Alerta do fluxo: Nenhum numero gerencial capturado na porta.\n") }
        senao
        {
            maior = n 
            menor = n
            
            enquanto (n != 0)
            {
                soma = soma + n 
                cont++
                
                se (n > maior) { maior = n }
                se (n < menor) { menor = n }
                
                escreva("Proximo Numero para registro: ") leia(n)
            }
            
            escreva("Estatistica de Quantidade final: ", cont, " | Soma acumulada da faixa: ", soma)
            escreva(" | Media padronizada: ", soma/cont, " | Deteccao de Maior pico: ", maior, " | Deteccao de Menor piso: ", menor, "\n")
        }
    }
}

programa
{
    funcao inicio()
    {
        const inteiro NUMERO_SECRETO = 42
        inteiro chute = -1, tent = 0
        
        escreva("Bem-vindo a logica. Adivinhe o parametro numerico isolado entre 1 e 100!\n")
        
        enquanto (chute != NUMERO_SECRETO)
        {
            escreva("Chute numerico: ") leia(chute) 
            tent++
            
            se (chute < NUMERO_SECRETO) { escreva("Diretriz: Valor lancado se encontra muito baixo na escala!\n") }
            senao se (chute > NUMERO_SECRETO) { escreva("Diretriz: Valor excedeu a fronteira e esta muito alto!\n") }
            senao { escreva("Vitoria atestada! ACERTOU na mosca consumindo exatas ", tent, " tentativas vitais!\n") }
        }
    }
}