(1 ponto) Faça um programa que receba um número inteiro de segundos e escreva em forma de anos (de 360 dias), meses (de 30 dias), dias ( 24 horas), horas ( 60 minutos), minutos ( 60 segundos) e segundos, sendo uma informação por linha, sempre com os nomes no plural

Passo 1

O que o problema pede e o que é dado:
  • Dado: um número inteiro de segundos (chamarei de S).
  • Pedido: escrever, uma informação por linha, a decomposição de S nas seguintes unidades (sempre com os nomes no plural):
    • anos (ano considerado com 360 dias);
    • meses (mês considerado com 30 dias);
    • dias ( 24 horas);
    • horas ( 60 minutos);
    • minutos ( 60 segundos);
    • segundos.
Ou seja, a saída deve ter exatamente 6 linhas, na ordem indicada, cada linha com algo como: " X anos", " Y meses", …, sempre usando o plural.

Passo 2

Entender as conversões e calcular quantos segundos existem em cada unidade básica.
Vamos calcular quantos segundos tem cada unidade, começando do minuto para cima:
  • Um minuto tem 60 segundos. Denotar s_{\text{min}} = 60.
  • Uma hora tem 60 minutos, logo
s_{\text{hora}} = 60\cdot s_{\text{min}} = 60\cdot 60 = 3600.
  • Um dia tem 24 horas, logo
s_{\text{dia}} = 24\cdot s_{\text{hora}} = 24\cdot 3600 = 86400.
  • Um mês (definido no enunciado como 30 dias) tem
s_{\text{mês}} = 30\cdot s_{\text{dia}} = 30\cdot 86400 = 2592000.ê
  • Um ano (definido no enunciado como 360 dias) tem
s_{\text{ano}} = 360\cdot s_{\text{dia}} = 360\cdot 86400 = 31104000.
Esses valores fixos são os “tijolos” que vamos usar para dividir S.

Passo 3

Explicar a técnica matemática usada: divisão inteira e resto (módulo).
Para decompor S em unidades maiores primeiro (anos), usamos:
\text{anos} = \left\lfloor \dfrac{S}{s_{\text{ano}}} \right\rfloor, \qquad r_1 = S \bmod s_{\text{ano}} = S - s_{\text{ano}}\cdot\text{anos}.
Depois usamos o resto r_1 para extrair meses:
\text{meses} = \left\lfloor \dfrac{r_1}{s_{\text{mês}}} \right\rfloor, \qquad r_2 = r_1 \bmod s_{\text{mês}}.êê
E repetimos o mesmo para dias, horas, minutos e finalmente os segundos restantes:
\text{dias} = \left\lfloor \dfrac{r_2}{s_{\text{dia}}} \right\rfloor,\quad r_3 = r_2 \bmod s_{\text{dia}},
\text{horas} = \left\lfloor \dfrac{r_3}{s_{\text{hora}}} \right\rfloor,\quad r_4 = r_3 \bmod s_{\text{hora}},
\text{minutos} = \left\lfloor \dfrac{r_4}{s_{\text{min}}} \right\rfloor,\quad \text{segundos} = r_4 \bmod s_{\text{min}}.
Aqui, \lfloor x\rfloor significa “parte inteira” de x (divisão inteira), e \bmod é o resto da divisão inteira. Esses são exatamente as operações feitas por // (divisão inteira) e % (módulo) em muitas linguagens, como Python.

Passo 4

Tradução disso para um algoritmo passo a passo (pseudocódigo mental):
  • Ler inteiro S.
  • Definir constantes s_{\text{min}}, s_{\text{hora}}, s_{\text{dia}}, s_{\text{mês}}, s_{\text{ano}}ê como no Passo 2.
  • Calcular anos = S // s_{\text{ano}}.
  • Atualizar S = S \% s_{\text{ano}} (agora S vira o resto).
  • Calcular meses = S // s_{\text{mês}}ê.
  • Atualizar S = S \% s_{\text{mês}}ê.
  • Calcular dias = S // s_{\text{dia}}.
  • Atualizar S = S \% s_{\text{dia}}.
  • Calcular horas = S // s_{\text{hora}}.
  • Atualizar S = S \% s_{\text{hora}}.
  • Calcular minutos = S // s_{\text{min}}.
  • Calcular segundos = S \% s_{\text{min}}.
  • Imprimir as 6 linhas:
    • " anos anos"
    • " meses meses"
    • " dias dias"
    • " horas horas"
    • " minutos minutos"
    • " segundos segundos"
Observação: o enunciado pede sempre os nomes no plural, então imprimimos “1 anos” se o valor for 1; não fazemos singularização.

Passo 5

Um exemplo numérico para fixar (faça como na prova: calcula na mão um exemplo pequeno).
Suponha S = 100000 segundos. Usando as constantes:
s_{\text{ano}}=31104000,\quad s_{\text{mês}}=2592000,\quad s_{\text{dia}}=86400,\quad s_{\text{hora}}=3600,\quad s_{\text{min}}=60.ê
  • anos = \left\lfloor\dfrac{100000}{31104000}\right\rfloor = 0. Resto r_1 = 100000.
  • meses = \left\lfloor\dfrac{100000}{2592000}\right\rfloor = 0. Resto r_2 = 100000.
  • dias = \left\lfloor\dfrac{100000}{86400}\right\rfloor = 1. Resto r_3 = 100000 - 1\cdot86400 = 13600.
  • horas = \left\lfloor\dfrac{13600}{3600}\right\rfloor = 3. Resto r_4 = 13600 - 3\cdot3600 = 2800.
  • minutos = \left\lfloor\dfrac{2800}{60}\right\rfloor = 46.
  • segundos = 2800 - 46\cdot60 = 40.
Resultado que o programa deve imprimir:
0 anos
0 meses
1 dias
3 horas
46 minutos
40 segundos
Esse tipo de cálculo é exatamente o que o programa fará automaticamente.

Passo 6

Dicas práticas para a prova e cuidados:
  • Use sempre divisão inteira e módulo na ordem de unidades decrescentes (maior para menor).
  • Declare as constantes de segundos por unidade para evitar erro de conta de cabeça.
  • Não tente decompor, por exemplo, em anos usando valores aproximados (como 365 dias) porque o enunciado já fixou 360 dias.
  • Assuma que S é um inteiro não-negativo (seja cuidadoso: se houver possibilidade de entrada negativa, o enunciado deveria dizer; normalmente, em provas, assume-se não-negativo).
  • Em linguagens como C, Java, Python a operação // (ou / com tipo inteiro) e % fazem o trabalho; em C/C++ e Java use / para divisão inteira quando os operandos são inteiros.

Passo 7

Implementação em Python (concreta, pronta para rodar). O código lê um inteiro da entrada padrão e imprime exatamente 6 linhas no formato pedido (sempre com nomes no plural).

Resposta

s = int(input())

s_min = 60
s_hora = 60 * s_min
s_dia = 24 * s_hora
s_mes = 30 * s_dia
s_ano = 360 * s_dia

anos = s // s_ano
s = s % s_ano

meses = s // s_mes
s = s % s_mes

dias = s // s_dia
s = s % s_dia

horas = s // s_hora
s = s % s_hora

minutos = s // s_min
segundos = s % s_min

print(f"{anos} anos")
print(f"{meses} meses")
print(f"{dias} dias")
print(f"{horas} horas")
print(f"{minutos} minutos")
print(f"{segundos} segundos")

Exercícios relacionados