Início
1 - contador ⟵ 1
2 - Enquanto contador <= 3 faça
Escrever contador
contador ⟵ contador +1
3 - FimEnquanto
Fim
Perguntas:
a) O que o algoritmo faz?
b) Quais valores serão exibidos na saída?

Passo 1

O enunciado pede duas coisas:
(a) dizer o que o algoritmo faz;
(b) listar quais valores serão exibidos na saída.
Informações dadas pelo enunciado (peguei exatamente do enunciado):
  • A primeira linha faz a atribuição inicial: contador \leftarrow 1.
  • Há um laço do tipo “Enquanto” com condição contador \le 3.
  • O corpo do laço executa duas ações, nesta ordem:
    1. Escrever contador (ou seja, imprimir o valor atual de contador na saída).
    2. Fazer contador \leftarrow contador + 1.
  • O laço termina em “FimEnquanto” e depois vem “Fim” do algoritmo.

Passo 2

Vamos entender como funciona um laço “Enquanto” (while) passo a passo — isso é essencial para responder (a) e (b).
Conceito básico do laço “Enquanto”:
  • Antes de cada repetição, a condição é avaliada. Se a condição for verdadeira, o corpo do laço é executado; se for falsa, o laço termina e o controle segue adiante.
  • A estrutura típica é:
    1. testar a condição;
    2. se verdadeira, executar o corpo (ações dentro do laço);
    3. depois do corpo, voltar ao passo 1;
    4. se a condição for falsa no teste, sair do laço.
No nosso caso a condição é contador \le 3. Isso significa “enquanto o valor de contador for menor ou igual a 3, execute o corpo”.
Também há uma atribuição que incrementa contador: contador \leftarrow contador + 1. Isso aumenta o valor de contador em uma unidade a cada iteração — é o que faz o laço progredir e, eventualmente, terminar.

Passo 3

Agora vamos simular a execução do algoritmo iteração por iteração (tracing). Em cada iteração mostro: valor antes do teste, resultado do teste, ação de escrita e valor após o incremento.
Iteração 1:
  • Antes do teste: contador = 1 (pela inicialização contador \leftarrow 1).
  • Teste da condição: 1 \le 3 é verdadeiro.
  • Executa o corpo: Escrever 1 — portanto a saída recebe o valor 1.
  • Incremento: faz-se contador \leftarrow 1 + 1, então agora contador = 2.
Iteração 2:
  • Antes do teste: contador = 2.
  • Teste da condição: 2 \le 3 é verdadeiro.
  • Executa o corpo: Escrever 2 — saída recebe 2 (em nova linha, normalmente).
  • Incremento: contador \leftarrow 2 + 1, agora contador = 3.
Iteração 3:
  • Antes do teste: contador = 3.
  • Teste da condição: 3 \le 3 é verdadeiro (lembre: é “menor ou igual”).
  • Executa o corpo: Escrever 3 — saída recebe 3.
  • Incremento: contador \leftarrow 3 + 1, agora contador = 4.
Iteração 4 (teste que encerra):
  • Antes do teste: contador = 4.
  • Teste da condição: 4 \le 3 é falso.
  • Como a condição é falsa, o laço termina e o algoritmo segue para “Fim” (nenhuma escrita adicional ocorre).

Passo 4

Interpretação do que aconteceu:
  • O laço começou em contador=1 e, enquanto contador era menor ou igual a 3, escreveu o valor atual e em seguida incrementou contador em 1.
  • Assim, os valores escritos foram exatamente os inteiros sucessivos 1, 2 e 3, cada um produzido em uma iteração.
  • Depois de escrever 3 e incrementar para 4, a condição passou a ser falsa e o laço terminou — por isso o algoritmo não entra em um laço infinito aqui (o incremento garante a progressão).
Observação didática rápida e útil para a prova:
  • Se a linha contador \leftarrow contador + 1 estivesse ausente, a condição contador \le 3 continuaria verdadeira para contador=1 e o laço seria infinito. Sempre verifique se um laço tem um avanço que o torne falso em algum momento, salvo quando se pretende um laço infinito.

Passo 5

Resumo curto do comportamento, que responde (a) e prepara (b):
  • O algoritmo imprime na saída uma sequência de números inteiros começando em 1, incrementando de 1 em 1, enquanto não ultrapassar 3. Em outras palavras: conta de 1 até 3 (inclusive).

Resposta

(a) O algoritmo escreve na saída os inteiros de 1 até 3 em ordem crescente (conta de 1 a 3, incrementando de 1 em 1).
(b) 1, 2, 3

Exercícios relacionados