Elaborar um programa em Pascal,que leia as ALTURAS em metros, de 120 atletas, calcule e imprima o valor da maior e da menor altura do grupo e quantos atletas são BAIXOS ( \mathrm{H}<1.80 ), quantos têm ALTURA MEDIANA ( 1.8<=\mathrm{H}<=1.95 ), quantas são altos ( \mathrm{H}>1.95 ) . RODE O PROGRAMA PARA UM GRUPO DE 6 ATLETAS.

Passo 1

O enunciado pede que a gente leia as ALTURAS em metros de um grupo de atletas (originalmente 120 atletas) e calcule e imprima:
  • a maior altura do grupo;
  • a menor altura do grupo;
  • quantos atletas são BAIXOS (condição H<1,80);
  • quantos têm ALTURA MEDIANA (condição 1,80 \le H \le 1,95);
  • quantos são ALTOS (condição H>1,95).
Informações relevantes fornecidas:
  • número total de atletas: 120 (o programa deve ser pensado para esse número);
  • categorias definidas pelas desigualdades: H<1,80, 1,80\le H\le 1,95, H>1,95;
  • pedido adicional do enunciado: “RODE O PROGRAMA PARA UM GRUPO DE 6 ATLETAS” — ou seja, além do programa para 120, precisamos demonstrar uma execução usando 6 alturas de exemplo.
Para a execução de demonstração vou usar o conjunto de 6 alturas abaixo (escolhidas para cobrir todas as categorias):
1,70;\;1,82;\;1,95;\;2,00;\;1,60;\;1,80

Passo 2

Ideia geral do método (sem código ainda): percorrer todas as alturas uma por uma e manter:
  • a maior altura encontrada até agora ( maior);
  • a menor altura encontrada até agora ( menor);
  • contadores para cada categoria: baixos, medianos, altos.
Ao ler cada nova altura h:
  1. Se h>maior atualiza maior := h.
  2. Se h<menor atualiza menor := h.
  3. Verifica em qual faixa h se encaixa para incrementar o contador correspondente:
    • se h<1,80 então baixos := baixos + 1;
    • senão se 1,80 \le h \le 1,95 então medianos := medianos + 1;
    • senão (ou seja, h>1,95) então altos := altos + 1.
Por que isso funciona? Porque ao varrer cada elemento uma vez e atualizar máximos/mínimos e contadores usando comparações simples, obtemos as informações desejadas com complexidade linear O(N) e sem precisar armazenar todas as alturas (memória constante).
Observação importante de implementação: para inicializar maior e menor de maneira segura, uma técnica simples é ler a primeira altura fora do laço e atribuí-la tanto a maior quanto a menor; isso evita usar valores extremos arbitrários.

Passo 3

Explicando as variáveis que vamos usar (bem mastigado):
  • N: número total de atletas que o programa vai ler (no enunciado N=120, para teste N=6).
  • i: índice do laço (inteiro) que vai de 1 até N.
  • h (ou altura): variável do tipo real que guarda a altura lida em metros, por exemplo 1,82.
  • maior: variável real que guarda a maior altura encontrada até o momento.
  • menor: variável real que guarda a menor altura encontrada até o momento.
  • baixos, medianos, altos: contadores inteiros iniciados em 0 que acumulam quantos atletas caem em cada faixa.
Tipos (em Pascal):
  • inteiros: integer;
  • reais (com casas decimais): real.
Observação prática sobre notação decimal no Pascal: no código fonte (Free Pascal/Turbo Pascal) usa-se ponto decimal, por exemplo 1.80. Nas explicações matemáticas em português escrevemos 1,80 com vírgula. Fique tranquilo — no código usaremos o formato que o compilador espera.

Passo 4

Aqui está o programa em Pascal bem explicado. Ele foi escrito para N=120 (conforme enunciado); para testar rápido você pode mudar a constante NUM para 6.
program Alturas;
const
NUM = 120; { Mude para 6 para testar a execução com 6 atletas }
var
i, baixos, medianos, altos: integer;
altura, maior, menor: real;
begin
baixos := 0; medianos := 0; altos := 0;
writeln('Digite ‘, NUM, ’ alturas em metros, uma por linha:’);
{ Leitura da primeira altura para inicializar maior e menor }
readln(altura);
maior := altura;
menor := altura;
{ Classifica a primeira altura }
if altura < 1.80 then baixos := baixos + 1
else if (altura >= 1.80) and (altura <= 1.95) then medianos := medianos + 1
else altos := altos + 1;
{ Leitura das demais alturas }
for i := 2 to NUM do
begin
readln(altura);
if altura > maior then maior := altura;
if altura < menor then menor := altura;
if altura < 1.80 then baixos := baixos + 1
else if (altura >= 1.80) and (altura <= 1.95) then medianos := medianos + 1
else altos := altos + 1;
end;
writeln('Maior altura: ‘, maior:0:2, ’ m’);
writeln('Menor altura: ‘, menor:0:2, ’ m’);
writeln('Baixos (H<1.80): ', baixos);
writeln('Altura mediana (1.80<=H<=1.95): ', medianos);
writeln('Altos (H>1.95): ', altos);
end.
Explicação linha a linha (resumida):
  • const NUM = 120; define quantos atletas o programa espera. Troque para 6 só para testar.
  • baixos := 0; medianos := 0; altos := 0; inicializa os contadores.
  • readln(altura); maior := altura; menor := altura; lê a 1ª altura e usa ela para inicializar maior e menor.
  • As estruturas if ... then ... else if ... else ... classificam cada altura nas faixas pedidas.
  • O for i := 2 to NUM do faz a leitura do resto das alturas e atualiza máximo, mínimo e contadores.
  • writeln(..., maior:0:2, ...) imprime os números com duas casas decimais.

Passo 5

Muito prático: por que inicializar com a primeira leitura? Porque se eu colocasse maior := 0.0 ou menor := 999.0 poderia introduzir erro caso todas as alturas fossem negativas (hipotético) ou maior que o valor escolhido. Inicializar com a primeira leitura garante consistência e é a técnica mais usada.
Agora vamos executar manualmente o algoritmo com os 6 valores de teste (lembrando que, para testar no código, basta mudar NUM := 6):
Conjunto de entrada (as 6 alturas escolhidas):
1,70;\;1,82;\;1,95;\;2,00;\;1,60;\;1,80
Passo a passo das iterações:
  • Iteração 1 (primeira leitura): h=1,70
    • maior := 1,70
    • menor := 1,70
    • classificação: 1,70 < 1,80 → baixos = 1, medianos = 0, altos = 0
  • Iteração 2: h=1,82
    • compara com maior: 1,82 > 1,70 → maior := 1,82
    • compara com menor: 1,82 < 1,70? não → menor permanece 1,70
    • classificação: 1,80 \le 1,82 \le 1,95 → medianos := 1
    • contadores agora: baixos = 1, medianos = 1, altos = 0
  • Iteração 3: h=1,95
    • 1,95 > 1,82 → maior := 1,95
    • menor permanece 1,70
    • 1,80 \le 1,95 \le 1,95 → medianos := 2
    • contadores: baixos = 1, medianos = 2, altos = 0
  • Iteração 4: h=2,00
    • 2,00 > 1,95 → maior := 2,00
    • menor permanece 1,70
    • classificação: 2,00 > 1,95 → altos := 1
    • contadores: baixos = 1, medianos = 2, altos = 1
  • Iteração 5: h=1,60
    • 1,60 > maior? não → maior permanece 2,00
    • 1,60 < menor? sim → menor := 1,60
    • classificação: 1,60 < 1,80 → baixos := 2
    • contadores: baixos = 2, medianos = 2, altos = 1
  • Iteração 6: h=1,80
    • 1,80 > maior? não → maior permanece 2,00
    • 1,80 < menor? não → menor permanece 1,60
    • classificação: 1,80 pertence à faixa mediana 1,80 \le H \le 1,95 → medianos := 3
    • contadores finais: baixos = 2, medianos = 3, altos = 1
Resultado final esperado (após varrer as 6 alturas): maior 2,00 m; menor 1,60 m; baixos 2; mediano 3; altos 1.

Passo 6

Dicas práticas para a prova (como lembrar e fazer rápido):
  • Pense em uma única varredura (um laço) — isso é suficiente para máximos, mínimos e contagem por categoria.
  • Inicialize máximo e mínimo com a primeira leitura para evitar pensar em “infinito”.
  • Use else if para não avaliar desnecessariamente condições (ganho pequeno de eficiência e evita duplas contagens).
  • No enunciado da prova, copie as desigualdades exatamente: H<1,80, 1,80\le H\le 1,95, H>1,95. Em dúvida sobre inclusão do limite 1,80 e 1,95, repare que o enunciado incluiu os limites na faixa mediana.

Resposta

Maior altura: 2,00 m
Menor altura: 1,60 m
Baixos (H<1,80): 2
Altura mediana (1,80\le H\le 1,95): 3
Altos (H>1,95): 1

Exercícios relacionados