O algoritmo apresentado

Esta questão parece ter alguns problemas. Do jeito que esta não há resposta correta. Agradeço se algum colega puder ajudar.

Existe um repita sem qualquer condição e sem fim-repita para delimitar o código no seu interior.

Também não há um fim-enquanto para o enquanto. De qualquer jeito, o código dentro do laço enquanto nunca será executado já que nos interessa justamente os números maiores que 1.

Penso que um pseudo-código correto seria:

var real: r

¨¨¨¨¨¨inteiro: n, aux

inicio

¨¨¨¨¨¨leia (n)

¨¨¨¨¨¨enquanto (n > 1) faça

¨¨¨¨¨¨¨¨¨¨¨¨r ← 1.0

¨¨¨¨¨¨¨¨¨¨¨¨para aux de 2 até n passo 1 faça

¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨r ← r + 1.0 / aux

¨¨¨¨¨¨¨¨¨¨¨¨fim-para

¨¨¨¨¨¨¨¨¨¨¨¨exiba(r)

¨¨¨¨¨¨¨¨¨¨¨¨n ← 0; // zera "n" para sair do enquanto

¨¨¨¨¨¨fim-enquanto

fim

Logo depois de exibir o resultado é preciso zerar o “n” para sair do enquanto.

Nesse caso o algoritmo realmente solucionaria r = 1 + ½ + 1/3 + …. 1/n para n maior que 1.

Outra solução seria levar o leia (n) para depois do enquanto que é a sugestão da letra “A”. É uma solução inadequada, pois, o correto é estabelecer a condição antes do enquanto, mas geraria o resultado desejado:

var real: r

¨¨¨¨¨¨inteiro: n, aux

inicio

¨¨¨¨¨¨n ← 0; // zero "n" para garantir que entraremos no bloco enquanto

¨¨¨¨¨¨enquanto (n <= 1) faça // aqui usamos a condição originalmente proposta

¨¨¨¨¨¨¨¨¨¨¨¨leia (n)

¨¨¨¨¨¨¨¨¨¨¨¨r ← 1.0

¨¨¨¨¨¨¨¨¨¨¨¨para aux de 2 até n passo 1 faça

¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨r ← r + 1.0 / aux

¨¨¨¨¨¨¨¨¨¨¨¨fim-para

¨¨¨¨¨¨¨¨¨¨¨¨exiba(r)

¨¨¨¨¨¨fim-enquanto

fim

Quando for lido um número igual ou menor que 1 o bloco para não será executado, será exibido “1” e o enquanto vai ser encerrado. De qualquer maneira, esse código capenga também solucionaria r = 1 + ½ + 1/3 + …. 1/n para n maior que 1.

O "Repita Enquanto" acredito que a banca quis supor o "Do While", mas realmente teria que ter um "Fim Enquanto".

Acredito que o gabarito seria alternativa menos errada já que o 2º Laço está correto.

1ª iteração r <--- r + 1/2

2ª iteração r <--- r + 1/2 + 1/3

N-ésima iteração r <--- r + 1/2 + 1/3 ... + 1/n

Gabarito: B

A) utiliza a condição enquanto incorretamente, pois ela deve vir antes da instrução leia.

ERRADO. Existem as duas formas de loop: ENQUANTO-REPITA e REPITA-ENQUANTO. Na primeira o teste é feita no início, na segunda o teste é feito no final. Não há problema.

B) resolve corretamente r = 1 + 1/2 + 1/3 + 1/4 +...+ 1/n, para n maior do que 1.

CERTO. O loop itera agregando "1/aux" em "r" em cada iteração, "aux" variando de 2 até n.

C) exibirá o valor 3.083 se for lido o valor 4 para n.

ERRADO. Para n=4, temos r= 1+ 1/2 + 1/3 + 1/4 = 25/12 = 2.083333...

D) gerará um erro de buffer overflow para valores de n maiores do que 10.

ERRADO. Não existe nenhum buffer para "estourar". A cada iteração é feita apenas uma soma decimal de números, e essa operação nunca vai estourar buffer.

E) tenta resolver a equação r = 1 + 1/2 + 1/4 +...+ 1/n, mas ocorrerá um erro se n for ímpar.

ERRADO. Não existe nenhum teste para verificar a paridade de "n", e nenhuma operação que falhe para n ímpar.

Força Guerreiro!!!!!!