Escreva um programa que lê um número n (sempre entre 1 e 100 ). Em se- guida, seu programa deve ler n números representando a idade (em anos) dos alunos matriculados em um determinado curso e calcular o histograma destas idades. Quais são as restrições da sua solução?

Passo 1

O enunciado pede duas coisas (vou listar direitinho):
  • Escrever um programa que leia um número n (sempre entre 1 e 100) e, em seguida, leia n números inteiros que representam as idades dos alunos matriculados em um curso, e calcule o histograma dessas idades.
  • Responder quais são as restrições da solução (isto é, quais pressupostos e limites que o programa exige ou que o avaliador/júri deve conhecer).
Informações relevantes dadas pelo enunciado:
  • O valor de n está garantido estar entre 1 e 100.
  • Devem ser lidas exatamente n idades (cada uma é um número; o enunciado não especificou explicitamente se são inteiros não-negativos, mas são “idades”, então assumiremos inteiros).
  • Objetivo: produzir o histograma das idades (contar quantas vezes cada idade aparece).

Passo 2

Escolha do método e ideia geral (explicação didática do conceito de histograma):
  • Um histograma, aqui, é simplesmente a contagem de frequência de cada valor de idade presente nos dados. Para cada idade a que aparecer nas entradas, queremos saber quantas vezes ela apareceu.
  • Duas estruturas comuns para fazer isso:
    1. Um dicionário (map) que associa cada idade a ao seu contador — flexível, só armazena idades que realmente aparecem.
    2. Um vetor (array) de contadores indexado pela idade — simples e rápido se soubermos um limite máximo para a idade (por exemplo, assumir idades em 0\ldots150).
  • Trade-off: o dicionário usa espaço proporcional ao número de idades distintas observadas; o array usa espaço proporcional ao intervalo máximo de idades assumido. Como n\le 100, ambas são muito eficientes. Vou escolher a abordagem com dicionário por ser robusta a qualquer intervalo razoável de idades fornecido.

Passo 3

Algoritmo passo a passo (em palavras) — isto é o que o programa fará:
  1. Ler o inteiro n.
  2. Validar (opcional) que 1 \le n \le 100. Se inválido, tratar como erro ou ajustar conforme política escolhida.
  3. Ler as próximas n idades (uma por vez ou em linha única).
  4. Para cada idade a lida:
    • Verificar se a é um inteiro (e, opcionalmente, se é não-negativo e dentro de um limite razoável).
    • Incrementar o contador associado a a no dicionário de frequências.
  5. Depois de processar todas as entradas, produzir a saída do histograma: por exemplo, listar cada idade presente e sua contagem (normalmente ordenando as idades em ordem crescente para leitura mais clara).

Passo 4

Programa exemplo (Python) — código claro e minimalista que implementa o algoritmo acima:
# Lê n e as n idades, calcula histograma e imprime idade: contagem em ordem crescente das idades

def main():
    import sys

    # Ler inteiro n
    line = sys.stdin.readline().strip()
    if not line:
        return
    try:
        n = int(line)
    except ValueError:
        print("Entrada invalida para n", file=sys.stderr)
        return

    # Opcional: validar n
    if n < 1 or n > 100:
        print("Valor de n fora do intervalo esperado [1, 100]", file=sys.stderr)
        return

    # Ler idades (aceita idades em várias linhas ou uma única linha)
    ages = []
    while len(ages) < n:
        parts = sys.stdin.readline().strip().split()
        if not parts:
            continue
        for p in parts:
            if len(ages) >= n:
                break
            try:
                a = int(p)
            except ValueError:
                print("Entrada invalida para idade:", p, file=sys.stderr)
                return
            ages.append(a)

    # Contar frequências usando dicionário
    freq = {}
    for a in ages:
        freq[a] = freq.get(a, 0) + 1

    # Imprimir histograma em ordem crescente de idade
    for age in sorted(freq.keys()):
        print(f"{age}: {freq[age]}")

if __name__ == "__main__":
    main()

Passo 5

Explicação detalhada do código linha a linha (para você conseguir entender e reproduzir na prova):
  • Leitura de n: o programa usa uma linha para ler n e tenta converter para inteiro. Se não for inteiro, dá erro. Em provas normalmente assumimos a entrada correta, mas é bom saber validar.
  • Validação de n: checamos 1 \le n \le 100. Isso vem do enunciado; se o avaliador garantir isso, a validação é redundante, mas protege contra entradas ruins.
  • Leitura das idades: o código vai acumulando entradas até coletar n inteiros. Isso permite que as idades venham em linhas separadas ou todas numa linha só — útil em competições/juízes automáticos.
  • Contador com dicionário:
    • freq = {} cria um mapa vazio.
    • Para cada idade a, freq[a] = freq.get(a, 0) + 1 aumenta a contagem; get(a,0) retorna 0 se a ainda não estava presente.
  • Impressão do histograma: para leitura organizada é comum ordenar as chaves. for age in sorted(freq.keys()) garante saída em ordem crescente de idade. Cada linha é idade: contagem.
  • Observação: o formato de saída pode variar conforme especificação do problema (alguns pedem só as contagens em ordem crescente de idade, outros pedem linhas com pares). Ajuste conforme necessário.

Passo 6

Justificativa da escolha (por que este método é apropriado para a prova):
  • Simplicidade: usar dicionário é direto e evita precisar conhecer um limite máximo de idade.
  • Eficiência: cada inserção/atualização no dicionário é, em média, O(1), então o algoritmo inteiro é O(n) em tempo.
  • Com n \le 100 o custo é trivial; a implementação é curta e pouco sujeita a bugs.

Passo 7

Casos especiais e robustez (o que eu preciso ter cuidado na hora da prova):
  • Se o avaliador esperar que idades sem ocorrência apareçam com contador zero, o programa atual não as imprimirá — ele só imprime idades que aparecem. Se for necessário imprimir um intervalo completo (por exemplo de 0 a 100), use um array fixo ou inicialize todo o intervalo com zero antes de incrementar.
  • Idades negativas: por definição de “idade” normalmente não esperamos negativas; se aparecerem, definir política (rejeitar entrada ou contar normalmente).
  • Entradas mal formatadas: em provas de programação muitas vezes a entrada segue o formato estrito; validação extra não é necessária, mas ajuda ao testar localmente.

Passo 8

Análise de complexidade e uso de memória (resposta técnica às restrições):
  • Tempo: a solução com dicionário faz um número de operações proporcional a n. Portanto, tempo é O(n).
  • Memória: usa espaço proporcional ao número de idades distintas observadas, no máximo \min(n, R) contadores, onde R é o tamanho do universo de idades possível. Com n\le 100, a memória é insignificante (por exemplo, no pior caso todas as idades são distintas: até 100 chaves).
  • Limite de entradas: o programa assume que serão fornecidos exatamente n inteiros após n. Se não houver entradas suficientes, o programa aguardará/retornará erro dependendo do ambiente.

Passo 9

Resumo dos pressupostos e restrições que compõem a resposta pedida (vou listar todas as restrições que a solução exige):
  • O valor de n satisfaz 1 \le n \le 100 (conforme enunciado).
  • As idades lidas são representadas por inteiros (pressuposto); se a entrada puder ter não-inteiros é necessário tratamento adicional.
  • O programa lê exatamente n idades; entrada com menos valores é considerada inválida.
  • A solução atual não impõe um limite máximo fixo de idade (usa dicionário), mas assume que idades cabem em um inteiro normal (por ex. dentro do intervalo de inteiros da linguagem usada). Para segurança prática, assumir idades em um intervalo razoável como 0 a 150.
  • Tempo de execução: O(n).
  • Memória usada: O(k) onde k é o número de idades distintas (no pior caso k \le n \le 100).
  • Formato de saída: imprime apenas idades que aparecem e suas contagens; se o problema exigir formato diferente, adaptar a saída.

Resposta

1 \le n \le 100
idades devem ser inteiros (pressuposto)
o programa lê exatamente n idades
tempo de execução O(n)
memória O(k) onde k é o número de idades distintas (no máximo n)
assunção prática: idades cabem num inteiro (ex.: intervalo esperado 0 a 150)

Exercícios relacionados