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?
1 - contador ⟵ 1
2 - Enquanto contador <= 3 faça
Escrever contador
contador ⟵ contador +1
3 - FimEnquanto
Fim
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.
(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:
. - Há um laço do tipo “Enquanto” com condição
. - O corpo do laço executa duas ações, nesta ordem:
- Escrever
(ou seja, imprimir o valor atual de na saída). - Fazer
.
- Escrever
- 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 é:
- testar a condição;
- se verdadeira, executar o corpo (ações dentro do laço);
- depois do corpo, voltar ao passo 1;
- se a condição for falsa no teste, sair do laço.
No nosso caso a condição é
. Isso significa “enquanto o valor de
for menor ou igual a
, execute o corpo”.
Também há uma atribuição que incrementa
:
. Isso aumenta o valor de
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:
(pela inicialização ). - Teste da condição:
é verdadeiro. - Executa o corpo: Escrever
— portanto a saída recebe o valor . - Incremento: faz-se
, então agora .
Iteração 2:
- Antes do teste:
. - Teste da condição:
é verdadeiro. - Executa o corpo: Escrever
— saída recebe (em nova linha, normalmente). - Incremento:
, agora .
Iteração 3:
- Antes do teste:
. - Teste da condição:
é verdadeiro (lembre: é “menor ou igual”). - Executa o corpo: Escrever
— saída recebe . - Incremento:
, agora .
Iteração 4 (teste que encerra):
- Antes do teste:
. - Teste da condição:
é 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
e, enquanto era menor ou igual a , escreveu o valor atual e em seguida incrementou em . - Assim, os valores escritos foram exatamente os inteiros sucessivos
, e , cada um produzido em uma iteração. - Depois de escrever
e incrementar para , 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
estivesse ausente, a condição continuaria verdadeira para 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
, incrementando de em , enquanto não ultrapassar . Em outras palavras: conta de até (inclusive).
Resposta
(a) O algoritmo escreve na saída os inteiros de
até
em ordem crescente (conta de
a
, incrementando de
em
).
(b) ,
,
(b)