Faça um algoritmo que leia 20 números e, ao final, escreva quantos estão entre 0 e 100.

Passo 1

O enunciado pede que a gente construa um algoritmo que leia \,20\, números e, ao final, escreva quantos desses números estão entre \,0\, e \,100\,.
Informações dadas e decisão de interpretação que vou adotar (clarificando porque enunciados às vezes são ambíguos):
  • Ler exatamente \,20\, valores de entrada (um por vez).
  • Contar quantos desses valores satisfazem a condição "entre \,0\, e \,100\,".
  • Vou considerar "entre \,0\, e \,100\," como inclusivo, ou seja, valores tais que \,0 \le x \le 100\,. (Se seu professor pedir exclusivo, basta trocar a condição para \,0 < x < 100\,.)

Passo 2

Definição das variáveis que o algoritmo vai usar (e o porquê):
  • \,contador\,: variável inteira que guarda quantos números já satisfazem a condição. Inicialmente \,contador = 0\,. Explicação didática: um contador é uma variável que usamos para acumular uma quantidade — sempre que encontramos um número que “vale”, aumentamos esse contador em uma unidade.
  • \,i\,: índice do laço que percorre as leituras de \,1\, até \,20\,. Explicação didática: \,i\, serve só para repetir a ação de ler um número \,20\, vezes; muitas linguagens têm laços que usam esse índice.
  • \,x\,: variável que armazena o número lido em cada iteração.

Passo 3

Estrutura lógica do algoritmo (alto nível), passo a passo, explicando conceitos:
  1. Inicializar \,contador = 0\,. Por que? Porque antes de ler qualquer número não há valores válidos contados.
  2. Repetir o seguinte bloco \,20\, vezes (laço): ler um número e testar se ele está no intervalo desejado; se estiver, incrementar o \,contador. Explicação didática do laço: um laço (loop) é uma instrução que repete algo várias vezes; aqui queremos repetir a ação “ler um número e testar” exatamente \,20\, vezes.
  3. Ao terminar as \,20\, iterações, escrever (mostrar) o valor de \,contador.
Detalhe sobre a condição: o teste que usamos é uma expressão booleana que avalia para verdadeiro ou falso. No nosso caso a condição é \,0 \le x \le 100\,. Em linguagens que não aceitam a cadeia \,0 \le x \le 100\, de uma vez, escreve-se como a conjunção \,(0 \le x) \text{ e } (x \le 100).

Passo 4

Pseudocódigo completo e explicado linha a linha. Vou escrever um pseudocódigo simples (fácil de transformar em qualquer linguagem) e explicar cada linha:
Pseudocódigo:
\begin{array}{l} \text{contador} \leftarrow 0 \\[4pt] \text{para } i \leftarrow 1 \text{ até } 20 \text{ faça} \\[4pt] \quad \text{ler } x \\[4pt] \quad \text{se } 0 \le x \le 100 \text{ então} \\[4pt] \quad\quad \text{contador} \leftarrow \text{contador} + 1 \\[4pt] \quad \text{fim se} \\[4pt] \text{fim para} \\[4pt] \text{escrever } \text{contador} \end{array}éçã
Explicação de cada linha:
  • \text{contador} \leftarrow 0: inicializa o contador em zero.
  • \text{para } i \leftarrow 1 \text{ até } 20 \text{ faça}éç: inicio do laço que vai repetir 20 vezes. Aqui \,i\, percorre de \,1\, a \,20\,.
  • \quad \text{ler } x: lê um número da entrada e guarda em \,x\,. Pode ser inteiro ou real; o algoritmo funciona para ambos.
  • \quad \text{se } 0 \le x \le 100 \text{ então}ã: testa se o número está entre \,0\, e \,100\,, inclusive.
  • \quad\quad \text{contador} \leftarrow \text{contador} + 1: se o teste for verdadeiro, acrescenta \,1\, ao contador.
  • \text{escrever } \text{contador}: depois do laço, imprime o total encontrado.]

Passo 5

Exemplo prático (passo a passo de uma execução pequena) para fixar a ideia:
Suponha que as primeiras \,8\, leituras sejam (apenas um exemplo): \,120, 0, 50, -3, 100, 100{,}1, 30, 0\,. Vou mostrar como o \,contador\, varia:
  • ler \,120\,: teste \,0 \le 120 \le 100\, é falso → \,contador = 0\,.
  • ler \,0\,: teste \,0 \le 0 \le 100\, é verdadeiro → \,contador = 1\,.
  • ler \,50\,: verdadeiro → \,contador = 2\,.
  • ler \,-3\,: falso → \,contador = 2\,.
  • ler \,100\,: verdadeiro → \,contador = 3\,.
  • ler \,100{,}1\,: falso → \,contador = 3\,.
  • ler \,30\,: verdadeiro → \,contador = 4\,.
  • ler \,0\,: verdadeiro → \,contador = 5\,.
    No final das \,20\, leituras, você imprime o valor acumulado (no exemplo parcial, \,5\, depois de 8 leituras).

Passo 6

Observações úteis para a prova e variantes rápidas (dicas práticas):
  • Se o enunciado exigir “entre \,0\, e \,100\, exclusive”, troque a condição para \,0 < x < 100\,.
  • Se quiser aceitar apenas inteiros, antes de testar você pode verificar se \,x\, é inteiro (dependendo da linguagem). Porém, a lógica do contador não muda.
  • Complexidade: algoritmo é \,O(20)=O(1)\, em termos práticos porque \,20\, é constante; ou seja, muito rápido.
  • Em prova, escreva claramente: inicializa contador, faça laço de \,1 a \,20, leia, teste, incremente, ao final escreva contador — avaliador quer ver esses passos.

Resposta

\begin{array}{l} \text{contador} \leftarrow 0 \\[4pt] \text{para } i \leftarrow 1 \text{ até } 20 \text{ faça} \\[4pt] \quad \text{ler } x \\[4pt] \quad \text{se } 0 \le x \le 100 \text{ então} \\[4pt] \quad\quad \text{contador} \leftarrow \text{contador} + 1 \\[4pt] \quad \text{fim se} \\[4pt] \text{fim para} \\[4pt] \text{escrever } \text{contador} \end{array}éçã]

Exercícios relacionados