Escrever um algoritmo que leia 50 valores, encontre o maior e o menor deles e mostre o resultado.

Passo 1

O que o enunciado pede e o que foi dado:
  • Pedido: escrever um algoritmo que leia 50 valores, encontre o maior e o menor entre eles e mostre esses resultados.
  • Dados/assunções: serão lidos exatamente 50 valores numéricos (podem ser inteiros ou reais). Não foi dito nada sobre tratamento de erro para entradas não numéricas, então assumimos que todas as leituras são válidas.
  • Saídas esperadas: dois números — o maior valor lido e o menor valor lido.

Passo 2

Ideia geral do método (explicação simples e intuitiva):
  • Percorrer os 50 valores um por um e manter duas variáveis que guardam, a todo momento, o maior e o menor valor vistos até aquele instante.
  • Sempre que um novo valor lido for maior que a variável que guarda o maior, atualizamos essa variável. Do mesmo modo, se o novo valor for menor que a variável que guarda o menor, atualizamos essa outra variável.
  • No final da leitura dos 50 valores, as duas variáveis contêm, respectivamente, o maior e o menor valor da sequência.

Passo 3

Por que inicializar com o primeiro valor lido (estratégia escolhida):
  • Uma forma segura de inicializar é ler o primeiro valor e atribuí-lo simultaneamente a maior e a menor. Assim evitamos depender de valores especiais como +\infty ou -\infty e funciona para qualquer tipo de número (positivo, negativo, zero).
  • Alternativa seria inicializar maior com um valor muito pequeno e menor com um valor muito grande, mas isso é desnecessário e arriscado. Usar o primeiro valor é mais simples e robusto.

Passo 4

Definição das variáveis que usaremos (com explicação do papel de cada uma):
  • x: variável que recebe cada valor lido do teclado (valor atual).
  • maior: guarda, a cada passo, o maior valor encontrado até então.
  • menor: guarda, a cada passo, o menor valor encontrado até então.
  • i: índice do laço, que vai controlar quantas leituras já foram feitas (vai de 1 a 50).

Passo 5

Descrição passo a passo do algoritmo (cada linha explicada):
  1. Leia o primeiro valor e armazene em x.
    • Explicação: essa leitura inicial serve para inicializar maior e menor.
  2. Faça maior \leftarrow x e menor \leftarrow x.
    • Explicação: agora tanto maior quanto menor têm um valor válido para comparação.
  3. Para i de 2 até 50 faça:
    • Leia um novo valor e armazene em x.
    • Se x > maior então faça maior \leftarrow x.
      • Explicação: se o valor atual for maior que o maior conhecido, atualizamos o maior.
    • Se x < menor então faça menor \leftarrow x.
      • Explicação: se o valor atual for menor que o menor conhecido, atualizamos o menor.
    • Volte para o próximo i até completar as 50 leituras.
  4. Depois do laço, escreva (mostre) maior e menor.
    • Explicação: ao final, essas variáveis contêm os resultados pedidos.

Passo 6

Exemplo rápido (para fixar a ideia) — passo a passo com poucos números:
  • Suponha as primeiras 5 leituras (só para exemplificar): 7,\\\ 3,\\\ 9,\\\ 5,\\\ 3.
  • Leitura 1: x=7. Inicializa maior=7, menor=7.
  • Leitura 2: x=3. Como 3>7? não. Como 3<7? sim → menor \leftarrow 3. Agora maior=7, menor=3.
  • Leitura 3: x=9. 9>7? sim → maior \leftarrow 9. 9<3? não. Agora maior=9, menor=3.
  • Leitura 4: x=5. 5>9? não. 5<3? não. Mantém maior=9, menor=3.
  • Leitura 5: x=3. 3>9? não. 3<3? não (é igual). Mantém maior=9, menor=3.
  • Ao final (após 50 leituras reais) as variáveis conterão o maior e o menor de toda a sequência.

Passo 7

Casos especiais e observações práticas:
  • Se todos os 50 valores forem iguais, maior e menor terão esse mesmo valor — tudo certo.
  • Se algum valor for negativo ou decimal, o método continua válido.
  • Se houver possibilidade de entradas inválidas (texto, etc.), o algoritmo real deveria validar cada leitura; aqui assumimos leituras numéricas válidas conforme enunciado.
  • O algoritmo realiza exatamente 49 comparações de > e < depois da primeira leitura (no total aprox. 2\times 49 comparações no pior caso), então é muito rápido. Se generalizarmos para n valores, a complexidade é O(n).

Passo 8

Implementação final (pseudocódigo claro e pronto para usar)
  • Abaixo está o pseudocódigo conciso que implementa tudo que expliquei. Ele pode ser copiado para um programa real com pequenas adaptações de sintaxe.

Resposta

Leia o primeiro valor e armazene em x
maior \leftarrow x
menor \leftarrow x
Para i \leftarrow 2 até 50 faça
\quad Leia x
\quad Se x > maior então maior \leftarrow x
\quad Se x < menor então menor \leftarrow x
Fim Para
Escreva maior
Escreva menor

Exercícios relacionados