Você foi contratado por uma empresa de logística para desenvolver um programa que ajude a categorizar pacotes conforme os códigos de transporte. Cada pacote possui um código numérico, e esses códigos precisam ser verificados para identificar se atendem a critérios específicos. A empresa utiliza os seguintes critérios:
  • Códigos múltiplos de 3 são enviados por transporte terrestre.
  • Códigos múltiplos de 5 são enviados por transporte marítimo.
  • Outros códigos são enviados por transporte aéreo.
No entanto, alguns códigos podem ser múltiplos de 3 e por 5 simultaneamente, ou seja, podem ser enviados por mais de um tipo de transporte. Nesse caso, dê prioridade ao transporte terrestre.
Implemente um programa que leia uma sequência arbitrária de números inteiros, representando os códigos dos pacotes, até que seja digitado o código 0 . Para cada código, com exceção do 0 , verifique se ele é múltiplo de 3,5 ou de nenhum deles, e identifique o meio de transporte a ser utilizado. Ao final, o programa deve imprimir como resultado:
  • A quantidade total de pacotes enviados por transporte terrestre.
  • A quantidade total de pacotes enviados por transporte marítimo.
  • A quantidade total de pacotes enviados por transporte aéreo.
Sua resposta deve conter as mensagens exatamente como definidas nos exemplos de execução.

Exemplo de Execução 1:

Digite um código: 10
Digite um código: 21
Digite um código: 7
Digite um código: 9
Digite um código: 0
Enviados por transporte terrestre: 2
Enviados por transporte marítimo: 1
Enviados por transporte aéreo: 1

Exemplo de Execução 2:

Digite um código: 11
Digite um código: 2
Digite um código: 1
Digite um código: 0
Enviados por transporte terrestre: 0
Enviados por transporte marítimo: 0
Enviados por transporte aéreo: 3

Passo 1

O que o problema pede (em partes claras):
  • Ler uma sequência de inteiros fornecidos pelo usuário, um por vez, até que o usuário digite o código 0. O 0 é apenas o sinal para parar; ele não deve ser contado como pacote.
  • Para cada código lido (exceto o 0), determinar o meio de transporte:
    • se for múltiplo de 3: transporte terrestre;
    • senão, se for múltiplo de 5: transporte marítimo;
    • senão: transporte aéreo.
  • Se um código for múltiplo de 3 e de 5 ao mesmo tempo (por exemplo 15), deve prevalecer transporte terrestre.
  • Ao final, imprimir três números: a quantidade total de pacotes enviados por transporte terrestre, por transporte marítimo e por transporte aéreo, com as mensagens exatamente como nos exemplos:
    • “Enviados por transporte terrestre: X”
    • “Enviados por transporte marítimo: Y”
    • “Enviados por transporte aéreo: Z”
Informações relevantes dadas pelo enunciado:
  • Entrada: sequência de inteiros, termina quando o inteiro for 0.
  • Critérios de classificação por múltiplos de 3 e 5 e prioridade ao múltiplo de 3.
  • Mensagens de saída devem coincidir exatamente com os exemplos.

Passo 2

Conceitos matemáticos e de programação que usaremos (explicados devagar e com exemplos):
  • Divisibilidade / múltiplo: dizer que um inteiro n é múltiplo de 3 significa que existe um inteiro k tal que n = 3k. Em termos operacionais (o que usamos no programa) verificamos se n \bmod 3 = 0.Aqui \bmod é a operação resto da divisão inteira.
  • Operação resto (módulo): para inteiros, n \bmod m é o resto da divisão de n por m. Se esse resto for 0, então n é múltiplo de m.
    • Exemplo: 21 \bmod 3 = 0 então 21 é múltiplo de 3.
    • Exemplo: 10 \bmod 5 = 0 então 10 é múltiplo de 5.
    • Exemplo: 7 \bmod 3 = 1 então 7 não é múltiplo de 3.
  • Estrutura de repetição com sentinela: usaremos um laço que lê valores até encontrar um valor especial (sentinela) que indica parar. Aqui a sentinela é 0.
  • Contadores: manteremos três variáveis que acumulam quantos pacotes caem em cada categoria. Inicialmente cada contador vale 0.
  • Ordem das verificações (prioridade): como pacotes múltiplos de 3 e de 5 simultaneamente devem ser classificados como terrestre, testamos primeiro a condição "múltiplo de 3". Se fizéssemos as verificações na ordem oposta (testar múltiplo de 5 antes), um número como 15 seria classificado como marítimo por engano. Portanto, a sequência deve ser: testar 3, senão testar 5, senão classificar como aéreo.

Passo 3

Algoritmo passo a passo (conceito, sem código-fonte definitivo):
  1. Inicialize três contadores: ter (terrestre) = 0, mar (marítimo) = 0, aer (aéreo) = 0.
  2. Repita:
    • Peça ao usuário para digitar um código.
    • Leia um inteiro n.
    • Se n = 0, pare o laço (não processe o 0).
    • Senão, se n \bmod 3 = 0 então incremente ter em 1.
    • Senão, se n \bmod 5 = 0 então incremente mar em 1.
    • Senão, incremente aer em 1.
  3. Depois de sair do laço, imprima:
    • "Enviados por transporte terrestre: " seguido do valor de ter
    • "Enviados por transporte marítimo: " seguido do valor de mar
    • "Enviados por transporte aéreo: " seguido do valor de aer
Observação sobre sinais e negativos: a definição de múltiplo vale também para inteiros negativos. Por exemplo, -9 \bmod 3 = 0 (ou equivalentemente -9 é múltiplo de 3), então este -9 cairia em terrestre. Em linguagens de programação comuns (por exemplo Python), a verificação n \% 3 == 0 funciona corretamente para negativos no sentido de identificar múltiplos.

Passo 4

Raciocínio sobre por que usar if-elif-else (explicação prática):
  • Se tivéssemos apenas testes independentes (como dois if separados), para um número como 15 ambos n \bmod 3 = 0 e n \bmod 5 = 0 seriam verdadeiros e poderíamos acabar contando duas categorias ao mesmo tempo. O problema exige apenas uma categoria por pacote, com prioridade para terrestre. Então, usamos:
    • primeiro um teste "se múltiplo de 3" (se verdadeiro, conta como terrestre e pula o resto),
    • senão, testamos "múltiplo de 5" (se verdadeiro, conta marítimo),
    • senão, conta aéreo.
  • Em pseudocódigo:
    ler n
    se n = 0 então parar
    senão se n % 3 == 0 então ter = ter + 1
    senão se n % 5 == 0 então mar = mar + 1
    senão aer = aer + 1
    

Passo 5

Simulação manual do primeiro exemplo para fixar (vou mostrar como os contadores evoluem; peguei os números do exemplo de execução):
  • Entrada 10: 10 \bmod 3 = 1 (não múltiplo de 3), 10 \bmod 5 = 0 (múltiplo de 5) → incrementa mar. Contadores agora ter=0,\; mar=1,\; aer=0.
  • Entrada 21: 21 \bmod 3 = 0 → terrestre (prioridade). Contadores: ter=1,\; mar=1,\; aer=0.
  • Entrada 7: não múltiplo de 3 nem de 5 → aéreo. Contadores: ter=1,\; mar=1,\; aer=1.
  • Entrada 9: 9 \bmod 3 = 0 → terrestre. Contadores: ter=2,\; mar=1,\; aer=1.
  • Entrada 0: parar e imprimir:
    • Enviados por transporte terrestre: 2
    • Enviados por transporte marítimo: 1
    • Enviados por transporte aéreo: 1
Isso coincide com o Exemplo de Execução 1.

Passo 6

Dicas de implementação e cuidados (para a prova ou para quando programar):
  • Certifique-se de converter a entrada para inteiro antes de aplicar o operador módulo.
  • Não conte o 0; use-o apenas como condição de parada.
  • Garanta que as mensagens impressas coincidam exatamente (acentuação, maiúsculas/minúsculas e pontuação), porque o enunciado pede isso.
  • A ordem dos testes é importante para respeitar a prioridade.
  • Complexidade e recursos: o algoritmo usa O(1) memória extra (apenas três contadores) e tempo linear no número de entradas lidas (cada entrada é classificada em tempo constante).

Passo 7

Motivação rápida e encorajamento
  • Você já tem todas as ferramentas: saber o que é múltiplo (módulo), saber usar um laço até sentinela e contar ocorrências. Vai dar certo — implemente isso calmamente e teste com os exemplos. Se errar, verifique a ordem dos testes (prioridade do múltiplo de 3) e se o 0 está sendo contado acidentalmente.

Resposta

ter = 0
mar = 0
aer = 0

while True:
    n = int(input("Digite um código: "))
    if n == 0:
        break
    if n % 3 == 0:
        ter += 1
    elif n % 5 == 0:
        mar += 1
    else:
        aer += 1

print("Enviados por transporte terrestre: {}".format(ter))
print("Enviados por transporte marítimo: {}".format(mar))
print("Enviados por transporte aéreo: {}".format(aer))

Exercícios relacionados