Faça um programa que leia “n” números e diga quantos estão acima de 1000 , quantos são iguais a 1000 e quantos estão abaixo de 1000.

Passo 1

O que o problema pede: ler \,n\, números e informar quantos estão acima de \,1000\,, quantos são iguais a \,1000\, e quantos estão abaixo de \,1000\,.
Informações dadas:
  • Há um inteiro \,n\, que diz quantos números vamos ler.
  • Em seguida vêm \,n\, valores (podem ser inteiros ou reais; o enunciado não especifica).
  • O valor de referência é \,1000\,.
O que precisamos entregar:
  • Três contagens: quantidade de valores com x>1000, quantidade com x=1000 e quantidade com x<1000.

Passo 2

Estratégia geral (bem simples): vamos percorrer os \,n\, números um a um e manter três contadores que começam em zero:
  • c_{maior} para contar quantos têm x>1000,
  • c_{igual} para contar quantos têm x=1000,
  • c_{menor} para contar quantos têm x<1000.
Para cada número lido x:
  • se x>1000 então incrementa c_{maior},
  • senão se x=1000 então incrementa c_{igual},
  • senão (ou seja, x<1000) incrementa c_{menor}.
No final, mostramos os três contadores.
Explicando as comparações (pra ficar bem claro):
  • A expressão x>1000 é verdadeira quando o valor de x é maior que \,1000\,.
  • A expressão x=1000 é verdadeira quando o valor de x é exatamente \,1000\,.
  • Se nenhuma das duas acima for verdadeira, então x<1000 (assumindo números reais), e contamos como menor.

Passo 3

Detalhes importantes e escolhas práticas:
  • Validação de \,n\,: convém que \,n\ge 0\,. Se \,n=0\, o laço não roda e os contadores continuam zero.
  • Tipo dos números: se o enunciado não diz, podemos aceitar números reais. Se aceitarmos reais, comparar igualdade com \,1000\, funciona bem quando o dado for exatamente \,1000\, (por exemplo, entrada “1000” ou “1000.0”). Em aplicações reais atenção ao problema de precisão de ponto flutuante, mas aqui vamos assumir entradas simples.
  • Ordem de verificação: verificar primeiro x>1000, depois x==1000, e por fim o caso restante é x<1000. Essa ordem evita erros lógicos.

Passo 4

Pseudocódigo (passo a passo, anotado explicando cada linha):
  1. Ler \,n\,. (Vai dizer quantas vezes repetir.)
  2. Inicializar \,c_{maior}=0\,, \,c_{igual}=0\,, \,c_{menor}=0\,.
  3. Repetir \,n\, vezes:
    3.1) Ler o próximo número e chamar de \,x\,.
    3.2) Se x>1000 então fazer c_{maior}\leftarrow c_{maior}+1.
    3.3) Senão se x=1000 então fazer c_{igual}\leftarrow c_{igual}+1.
    3.4) Senão fazer c_{menor}\leftarrow c_{menor}+1.
  4. Depois do laço, imprimir c_{maior}, c_{igual} e c_{menor}.
Exemplo concreto para fixar (faça mentalmente como durante a prova):
  • Suponha \,n=5\, e os números lidos forem \,800,\,1000,\,1200,\,1000,\,500\,.
    • Começamos com (c_{maior},c_{igual},c_{menor})=(0,0,0).
    • Ler 800: 800>1000? não. 800=1000? não. Então c_{menor}=1.
    • Ler 1000: 1000>1000? não. 1000=1000? sim. Então c_{igual}=1.
    • Ler 1200: 1200>1000? sim. Então c_{maior}=1.
    • Ler 1000: incrementa c_{igual} para 2.
    • Ler 500: incrementa c_{menor} para 2.
    • Resultado final: c_{maior}=1, c_{igual}=2, c_{menor}=2.

Passo 5

Dicas para escrever rápido na prova:
  • Use nomes curtos para contadores como c_m, c_i, c_l se quiser (mas aqui usei nomes descritivos para clareza).
  • Não complique: um único laço for/while resolve o problema.
  • Se no enunciado pedirem saída em formato específico (por ex. uma linha só com três números), adapte a impressão final para o formato pedido.
  • Teste mentalmente com 2–3 exemplos pequenos para garantir que o laço e as condições estão corretas.

Passo 6

Agora, um exemplo de implementação prática em Python. Esse programa lê primeiro \,n\,, depois lê \,n\, números (um por linha) e no final imprime quantos estão acima de \,1000\,, iguais a \,1000\, e abaixo de \,1000\,. Use esse código como base — é curto e direto, ótimo para colocar numa prova prática ou exercício.

Resposta

n = int(input())
c_maior = 0
c_igual = 0
c_menor = 0
for _ in range(n):
x = float(input())
if x > 1000:
c_maior += 1
elif x == 1000:
c_igual += 1
else:
c_menor += 1
print(f"Acima de 1000: {c_maior}")
print(f"Igual a 1000: {c_igual}")
print(f"Abaixo de 1000: {c_menor}")

Exercícios relacionados