A confederação brasileira de natação irá promover eliminatórias para o próximo mundial. Fazer um programa que receba uma letra e informe qual a faixa etária o nadador tem que estar segundo a tabela abaixo.
Categoria Idade
A 5-7 anos
B 8-10 anos
C 11-13 anos
D 14-17 anos
S Maiores que 18 anos

Passo 1

O enunciado pede que a gente faça um programa que receba uma letra (categoria) e informe qual a faixa etária correspondente segundo a tabela fornecida. Pergunta implícita: dado um caractere de entrada, qual é a mensagem de saída com a faixa etária?
Informações relevantes dadas no enunciado (peguei diretamente da tabela do enunciado):
  • Categoria A \to faixa etária 5-7 anos.
  • Categoria B \to faixa etária 8-10 anos.
  • Categoria C \to faixa etária 11-13 anos.
  • Categoria D \to faixa etária 14-17 anos.
  • Categoria S \to faixa etária "Maiores que 18" anos.
A obrigação do programa: ler uma letra e imprimir a faixa etária correspondente. Também é razoável tratar entradas inválidas (ou letras fora das listadas) e considerar letras minúsculas e maiúsculas como equivalentes (por exemplo, a e A devem ser tratadas igual).

Passo 2

Vamos determinar qual é a saída esperada para cada entrada — isto simplifica muito a implementação.
Mapeamento direto (resumo):
  • Entrada A → saída: “5-7 anos”
  • Entrada B → saída: “8-10 anos”
  • Entrada C → saída: “11-13 anos”
  • Entrada D → saída: “14-17 anos”
  • Entrada S → saída: “Maiores que 18 anos”
  • Qualquer outra entrada → saída: “Categoria inválida” (mensagem de erro amigável)
Explicação didática: esse é um caso típico de mapeamento discreto entre conjunto de categorias e rótulos. Em programação, usamos estruturas condicionais (if/elif/else) ou uma tabela (dicionário/map) para implementar esse mapeamento.

Passo 3

Conceito e fórmula simples (aula rápida):
  • Estruturas condicionais: usamos quando precisamos executar ações diferentes dependendo de um valor. Em pseudocódigo:
\text{se }(\text{letra} = 'A')\\ \text{então}\\ \text{imprimir}("5-7\\ anos")ã
\text{senao se }(\text{letra} = 'B')\\ \text{então}\\ \text{imprimir}("8-10\\ anos")ã
\ldots
\text{senao}\\ \text{imprimir}("Categoria\\ inválida")á
  • Alternativa (mais elegante): usar um dicionário (mapa) onde cada chave é a categoria e o valor é a faixa etária. Em linguagem de alto nível isso vira algo como:
\text{mapa} = \{\\ 'A':'5-7\\ anos',\\ 'B':'8-10\\ anos',\\ \ldots\\ \}
e depois consultamos \text{mapa[letra]}, tratando o caso em que a chave não existe.

Passo 4

Tratamento de entrada (detalhes práticos que salvam na prova):
  • Receber o caractere como texto.
  • Remover espaços extras nas extremidades (função trim/strip).
  • Converter para maiúscula para eliminar diferença entre a e A. Em pseudocódigo:
\text{letra} \leftarrow \text{entrada}.trim().toUpperCase()
Isso evita erros bobos em provas por causa de espaço ou caixa (maiúscula/minúscula).

Passo 5

Escolha do método para implementar (explicando por que):
  • Método 1: if/elif/else — simples, direto; bom quando número de categorias é pequeno (aqui são 5).
  • Método 2: dicionário/map — mais elegante, fácil de expandir, código menor.
    Vou mostrar as duas abordagens; na prova, if/elif é seguro e explícito, mas usar dicionário é uma boa prática.

Passo 6

Pseudocódigo (passo a passo, faça assim na prova se pedir algoritmo):
\text{// Ler entrada}
\text{letra} \leftarrow \text{lerLinha}()
\text{letra} \leftarrow \text{letra.trim().toUpperCase()}
\text{se letra = 'A' entao imprimir("5-7 anos")}
\text{senao se letra = 'B' entao imprimir("8-10 anos")}
\text{senao se letra = 'C' entao imprimir("11-13 anos")}
\text{senao se letra = 'D' entao imprimir("14-17 anos")}
\text{senao se letra = 'S' entao imprimir("Maiores que 18 anos")}
\text{senao imprimir("Categoria inválida")}á

Passo 7

Exemplo concreto passo-a-passo (simulando execução):
  • Suponha que a entrada seja \text{" b "} (com espaços e minúscula).
  • Aplico trim e toUpperCase → \text{"B"}.
  • Checo as condições: encontra B → imprime 8-10 anos.
  • Resultado exibido: “8-10 anos”.
Isso mostra por que normalizar a entrada evita erros.

Passo 8

Exemplo de implementação em Python (comentado, para entender linha a linha). Este é um código que você pode escrever rapidamente numa prova prática ou num exercício de laboratório:
def faixa_etaria(letra):
    letra = letra.strip().upper()        # remove espaços e coloca em maiúscula
    if letra == 'A':
        return "5-7 anos"
    elif letra == 'B':
        return "8-10 anos"
    elif letra == 'C':
        return "11-13 anos"
    elif letra == 'D':
        return "14-17 anos"
    elif letra == 'S':
        return "Maiores que 18 anos"
    else:
        return "Categoria inválida"

# exemplo de uso
entrada = input("Digite a categoria (A, B, C, D, S): ")
print(faixa_etaria(entrada))
Explicação das linhas:
  • strip() remove espaços; upper() transforma em maiúscula.
  • if/elif/else implementam o mapeamento.
  • Função faixa_etaria permite testar facilmente várias entradas.

Passo 9

Versão alternativa usando dicionário (mais curta e escalável):
def faixa_etaria(letra):
    tabela = {
        'A': "5-7 anos",
        'B': "8-10 anos",
        'C': "11-13 anos",
        'D': "14-17 anos",
        'S': "Maiores que 18 anos"
    }
    letra = letra.strip().upper()
    return tabela.get(letra, "Categoria inválida")

entrada = input("Digite a categoria (A, B, C, D, S): ")
print(faixa_etaria(entrada))
Aqui tabela.get(letra, "Categoria inválida") busca o valor e, se não existir, retorna a mensagem padrão — isso evita vários elif.

Passo 10

Casos de teste rápidos (para você praticar antes da prova):
  • Entrada A → saída esperada: “5-7 anos”
  • Entrada c → saída esperada: “11-13 anos”
  • Entrada S → saída esperada: “Maiores que 18 anos”
  • Entrada X → saída esperada: “Categoria inválida”
  • Entrada com espaços: " d " → “14-17 anos”
Faça esses testes manualmente ou executando o programa — isso dá confiança.

Passo 11

Dicas para a prova (motivação e truques práticos):
  • Sempre normalize entrada (trim + upper) — evita tempo perdido com erros de formato.
  • Se a questão pedir só o algoritmo, escreva o pseudocódigo do Passo 6; se pedir código, use a estrutura do Passo 8 ou 9.
  • Seja explícito com a mensagem de erro (“Categoria inválida”) — mostra pensamento completo ao corrigidor.
  • Não esqueça de tratar letras minúsculas; corrigidores valorizam isso.

Resposta

def faixa_etaria(letra):
    letra = letra.strip().upper()
    if letra == 'A':
        return "5-7 anos"
    elif letra == 'B':
        return "8-10 anos"
    elif letra == 'C':
        return "11-13 anos"
    elif letra == 'D':
        return "14-17 anos"
    elif letra == 'S':
        return "Maiores que 18 anos"
    else:
        return "Categoria inválida"

entrada = input("Digite a categoria (A, B, C, D, S): ")
print(faixa_etaria(entrada))

Exercícios relacionados