Escrever um algoritmo/programa em Pascal que lê 20 valores, um de cada vez, e conta quantos deles estão em cada um dos intervalos [ 0,25 ], (25,50], (50,75], (75,100], escrevendo esta informação.

Passo 1

O que o enunciado pede e quais são os dados fornecidos.
  • O programa deve ler exatamente 20 valores, um por vez.
  • Para esses 20 valores, deve contar quantos caem em cada um dos quatro intervalos:
    • [0,25]
    • (25,50]
    • (50,75]
    • (75,100]
  • No final, o programa deve escrever (imprimir) a quantidade de valores em cada intervalo.
  • Observação prática: o enunciado não fala explicitamente sobre valores fora de 0 a 100. Vou explicar como tratar esses casos e vou incluir uma contagem opcional para valores fora desses intervalos (útil para depuração).

Passo 2

Entendendo os intervalos e as regras de inclusão/exclusão de extremos.
  • Intervalo [0,25] significa: inclui 0 e inclui 25. Em notação lógica, um valor x está em [0,25] se e somente se 0 \le x \le 25.
  • Intervalo (25,50] significa: não inclui 25, inclui 50. Em lógica: 25 < x \le 50.
  • Intervalo (50,75] significa: 50 < x \le 75.
  • Intervalo (75,100] significa: 75 < x \le 100.
Importante: a maneira como testamos essas condições no programa tem que respeitar essa ordem de inclusão/exclusão. Por exemplo, um valor exatamente igual a 25 pertence ao primeiro intervalo [0,25], não ao segundo.

Passo 3

Escolha dos tipos de variáveis (em Pascal) e contadores.
  • Vamos ler valores que podem ser números com parte fracionária: use tipo real para a variável que recebe cada entrada, chamarei de v.
  • Precisamos de quatro contadores inteiros (tipo integer) para contar quantos caem em cada intervalo. Nomearei:
    • c1 para [0,25]
    • c2 para (25,50]
    • c3 para (50,75]
    • c4 para (75,100]
  • Opcionalmente, um contador cout para valores fora de 0 a 100 (se desejar mostrar).

Passo 4

Estrutura geral do algoritmo — laço de leitura e decisões.
  • Fazer um laço que execute exatamente 20 vezes: for i := 1 to 20 do.
  • Em cada iteração:
    1. Ler o valor em v (um real).
    2. Testar, em ordem, qual condição de intervalo é satisfeita:
      • Se 0 \le v \le 25 então incrementar c1.
      • Senão, se 25 < v \le 50 então incrementar c2.
      • Senão, se 50 < v \le 75 então incrementar c3.
      • Senão, se 75 < v \le 100 então incrementar c4.
      • Senão (caso v esteja fora do conjunto [0,100]), incrementar cout (opcional).
  • Usar a ordem das condições exatamente como acima evita ambiguidade nos limites 25,50,75.

Passo 5

Como escrever as condições em Pascal (detalhe prático).
  • Em Pascal usamos operadores relacionais <=, <, > e o operador lógico and.
  • A condição 0 \le v \le 25 vira em Pascal: (v >= 0) and (v <= 25).
  • A condição 25 < v \le 50 vira: (v > 25) and (v <= 50).
  • E assim por diante.
  • É importante colocar parênteses porque and e os comparadores precisam de agrupamento claro.

Passo 6

Tratamento de entradas inválidas e comportamento desejado.
  • O enunciado apenas pede a contagem nos intervalos; não exige avisos para entradas inválidas.
  • Porém, é boa prática:
    • contar quantos valores ficaram fora de [0,100] (contador cout) e opcionalmente mostrar.
    • não interromper a leitura se aparecer um valor fora da faixa — apenas contar como “fora”.
  • Na versão que vou fornecer, eu incluo cout e mostro esse número ao final; se preferir, basta remover cout e o ramo correspondente.

Passo 7

Pseudocódigo simples (para entender antes do código Pascal).
  • Inicializar c1 := 0, c2 := 0, c3 := 0, c4 := 0, cout := 0.
  • Para i de 1 até 20:
    • Ler v.
    • Se (v >= 0) and (v <= 25) então c1 := c1 + 1
    • Senão se (v > 25) and (v <= 50) então c2 := c2 + 1
    • Senão se (v > 50) and (v <= 75) então c3 := c3 + 1
    • Senão se (v > 75) and (v <= 100) então c4 := c4 + 1
    • Senão cout := cout + 1
  • Imprimir c1, c2, c3, c4 (e cout se quiser).

Passo 8

Programa Pascal completo e comentado (copia e cole no seu compilador).
program ContadorIntervalos;
{ Lê 20 valores e conta quantos estão em cada intervalo:
  [0,25], (25,50], (50,75], (75,100]
  Também conta valores fora de [0,100] (cout) para informação. }

var
  i: integer;
  v: real;
  c1, c2, c3, c4, cout: integer;

begin
  { Inicializa contadores }
  c1 := 0;
  c2 := 0;
  c3 := 0;
  c4 := 0;
  cout := 0;

  writeln('Entre com 20 valores (um por linha):');

  { Loop de leitura das 20 entradas }
  for i := 1 to 20 do
  begin
    readln(v);

    if (v >= 0) and (v <= 25) then
      c1 := c1 + 1
    else if (v > 25) and (v <= 50) then
      c2 := c2 + 1
    else if (v > 50) and (v <= 75) then
      c3 := c3 + 1
    else if (v > 75) and (v <= 100) then
      c4 := c4 + 1
    else
      cout := cout + 1; { valor fora de [0,100] }
  end;

  { Impressão dos resultados }
  writeln('Quantidade em [0,25]: ', c1);
  writeln('Quantidade em (25,50]: ', c2);
  writeln('Quantidade em (50,75]: ', c3);
  writeln('Quantidade em (75,100]: ', c4);
  writeln('Quantidade fora de [0,100]: ', cout);
end.

Passo 9

Explicação linha a linha (ajuda para a prova — entenda o que faz cada parte)
  • program ContadorIntervalos; — nome do programa.
  • var i: integer; v: real; ... — declaração das variáveis; v recebe cada valor lido, os c1..c4 e cout acumulam as contagens.
  • for i := 1 to 20 do — repete o bloco exatamente 20 vezes, como o enunciado pede.
  • readln(v); — lê um valor (pode ser real).
  • A cadeia if ... else if ... else garante que cada valor seja contado em no máximo um dos contadores e que os limites sejam tratados conforme a especificação ( 25 entra no primeiro, 50 no segundo, etc.).
  • As últimas writeln exibem os resultados. A linha com cout é opcional; mostra quantos valores estavam fora de [0,100].

Passo 10

Dicas para a prova e pontos que costumam cair:
  • Não se esqueça dos sinais de igualdade nos extremos: o primeiro intervalo inclui 25, então use <= 25 nele. Valores exatamente iguais a 25 não devem ser testados no segundo intervalo.
  • Verifique a ordem das condições: se fizesse if v <= 50 then ... sem checar antes o primeiro intervalo, poderia contar errado. Por isso colocar o teste de [0,25] primeiro é seguro.
  • Sempre inicialize os contadores com zero antes do laço.
  • Se a entrada for inteira no enunciado, dá para usar integer para v, mas usar real é mais geral e seguro (se entrarem números fracionários).
  • Teste seu programa com casos limites: 0, 25, 50, 75, 100 e com valores menores que 0 ou maiores que 100.

Resposta

program ContadorIntervalos;
{ Lê 20 valores e conta quantos estão em cada intervalo:
  [0,25], (25,50], (50,75], (75,100]
  Também conta valores fora de [0,100] (cout) para informação. }

var
  i: integer;
  v: real;
  c1, c2, c3, c4, cout: integer;

begin
  { Inicializa contadores }
  c1 := 0;
  c2 := 0;
  c3 := 0;
  c4 := 0;
  cout := 0;

  writeln('Entre com 20 valores (um por linha):');

  { Loop de leitura das 20 entradas }
  for i := 1 to 20 do
  begin
    readln(v);

    if (v >= 0) and (v <= 25) then
      c1 := c1 + 1
    else if (v > 25) and (v <= 50) then
      c2 := c2 + 1
    else if (v > 50) and (v <= 75) then
      c3 := c3 + 1
    else if (v > 75) and (v <= 100) then
      c4 := c4 + 1
    else
      cout := cout + 1; { valor fora de [0,100] }
  end;

  { Impressão dos resultados }
  writeln('Quantidade em [0,25]: ', c1);
  writeln('Quantidade em (25,50]: ', c2);
  writeln('Quantidade em (50,75]: ', c3);
  writeln('Quantidade em (75,100]: ', c4);
  writeln('Quantidade fora de [0,100]: ', cout);
end.

Exercícios relacionados