Considere o problema da soma de dois ângulos no formato grau (d), minuto (m) e segundo (s), conforme o exemplo apresentado a seguir para a soma dos ângulos 20d50m37s e 7d43m42s:
Ângulo 1: 20d50m37s
Ângulo 2: 7d43m42s
Soma...: 28d34m19s
a) Elabore um algoritmo para realizar a soma de dois ângulos no formato grau, minuto e segundo, considerando todos os números inteiros. Não utilize lógica condicional no seu algoritmo, apenas operações matemáticas.
b) Desenvolva um programa no qual o usuário entra com dois ângulos, de acordo com o formato grau, minuto e segundo (máscara de leitura de um ângulo: \% d d \% d m \% d s ) e seja exibido na tela o valor da soma desses ângulos, também no formato grau, minuto e segundo.

Passo 1

O enunciado pede duas coisas:
  1. (a) Elaborar um algoritmo que some dois ângulos dados no formato grau, minuto e segundo — isto é, soma de ângulo s do tipo \(d, m, s) — usando apenas operações matemáticas, sem nenhuma lógica condicional.
  2. (b) Implementar um programa em que o usuário entra com dois ângulos no formato máscara "%dd%dm%ds" e o programa exibe a soma também em "%dd%dm%ds".
Informações relevantes dadas:
  • Cada ângulo é representado por três inteiros: grau \(d), minuto \(m) e segundo \(s).
  • Convenções de unidade: 1 grau =60 minutos e 1 minuto =60 segundos.
  • Exemplo do enunciado: somando \(20d50m37s) e \(7d43m42s) obtém-se \(28d34m19s) — usaremos isto para checar o algoritmo.

Passo 2

Entendendo o que acontece quando somamos em um sistema com “base” (sistema posicional com carry):
  • Segundos somam-se entre si; se o total de segundos for maior ou igual a 60, devemos “carregar” minutos.
  • Minutos somam-se entre si (mais o carry de segundos); se o total de minutos for maior ou igual a 60, devemos “carregar” graus.
  • Graus somam-se entre si (mais o carry de minutos). Aqui não há limite superior (podemos deixar graus qualquer inteiro).
Conceito matemático que vamos usar e que não é condicional:
  • Divisão inteira (p.ex. em muitas linguagens o operador / entre inteiros dá a parte inteira do quociente) e resto (módulo). Em matemática usamos \left\lfloor \cdot \right\rfloor ou o operador \bmod.
  • Vamos usar a ideia: dado o total de segundos S, o número de minutos a transportar é \left\lfloor S/60 \right\rfloor e os segundos finais são S \bmod 60. Isso é somente aritmética, sem teste if/then.

Passo 3

Definir variáveis (nomes e significado):
  • Para o primeiro ângulo: \(d_1, m_1, s_1).
  • Para o segundo ângulo: \(d_2, m_2, s_2).
  • Variáveis auxiliares de soma: \(S) para segundos totais, \(M) para minutos totais, \(D) para graus totais.
  • Variáveis de carry (transportes): \(c_m) para minutos vindos dos segundos, \(c_d) para graus vindos dos minutos.
  • Resultado final: \(d, m, s).

Passo 4

Fórmulas matemáticas (sem condicionais) — passo a passo derivado da lógica de carry:
  1. Somar os segundos:
S = s_1 + s_2
  1. Calcular quantos minutos transportar a partir dos segundos (divisão inteira) e os segundos finais (resto):
c_m = \left\lfloor \dfrac{S}{60} \right\rfloor
s = S \bmod 60
(obs.: S \bmod 60 = S - 60\left\lfloor S/60\right\rfloor. Use a forma disponível na linguagem que for usar.)
  1. Somar os minutos incluindo o carry dos segundos:
M = m_1 + m_2 + c_m
  1. Calcular quantos graus transportar a partir dos minutos e os minutos finais:
c_d = \left\lfloor \dfrac{M}{60} \right\rfloor
m = M \bmod 60
  1. Somar os graus incluindo o carry dos minutos:
d = d_1 + d_2 + c_d
Pronto — todas as operações são soma, divisão inteira e resto (sem nenhum if).

Passo 5

Exemplo numérico aplicado (usar o exemplo do enunciado para verificar e para você ver passo a passo):
  • Dados: \(d_1=20, m_1=50, s_1=37) e \(d_2=7, m_2=43, s_2=42).
  1. \displaystyle S = 37 + 42 = 79.
  2. \displaystyle c_m = \left\lfloor 79/60 \right\rfloor = 1.
  3. \displaystyle s = 79 \bmod 60 = 79 - 60\cdot 1 = 19.
  4. \displaystyle M = 50 + 43 + 1 = 94.
  5. \displaystyle c_d = \left\lfloor 94/60 \right\rfloor = 1.
  6. \displaystyle m = 94 \bmod 60 = 94 - 60\cdot 1 = 34.
  7. \displaystyle d = 20 + 7 + 1 = 28.
Resultado: \(28d34m19s) — coincide com o enunciado, logo as fórmulas estão corretas.

Passo 6

Algoritmo em pseudocódigo detalhado (sem condicionais), escrito passo a passo para você transpor para qualquer linguagem:
  • Entrada: inteiros \(d_1, m_1, s_1, d_2, m_2, s_2).
  • Passos:
    1. Calcule \displaystyle S \leftarrow s_1 + s_2.
    2. Calcule \displaystyle c_m \leftarrow \left\lfloor S/60 \right\rfloor.
    3. Calcule \displaystyle s \leftarrow S \bmod 60.
    4. Calcule \displaystyle M \leftarrow m_1 + m_2 + c_m.
    5. Calcule \displaystyle c_d \leftarrow \left\lfloor M/60 \right\rfloor.
    6. Calcule \displaystyle m \leftarrow M \bmod 60.
    7. Calcule \displaystyle d \leftarrow d_1 + d_2 + c_d.
  • Saída: inteiros \(d, m, s) representando a soma no formato grau, minuto e segundo.
Explicação sobre como implementar \left\lfloor \cdot \right\rfloor e \bmod em programação:
  • Em C (e em muitas linguagens), para inteiros positivos, \left\lfloor S/60 \right\rfloor é simplesmente S/60 usando divisão inteira, e S \bmod 60 é S\%60. Não há if: são operadores aritméticos.

Passo 7

Programa em C (leitura com máscara solicitada e sem uso de condicionais). Este código lê dois ângulos com a máscara "%dd%dm%ds", soma usando apenas aritmética inteira e imprime o resultado no mesmo formato.
#include <stdio.h>
int main(void) {
int d1, m1, s1;
int d2, m2, s2;
int S, c_m, s;
int M, c_d, m;
int d;
/* Leitura do primeiro ângulo no formato %dd%dm%ds */
scanf("%dd%dm%ds", &d1, &m1, &s1);

/* Leitura do segundo ângulo no formato %dd%dm%ds */
scanf("%dd%dm%ds", &d2, &m2, &s2);

/* Soma dos segundos e cálculo do carry para minutos */
S = s1 + s2;
c_m = S / 60;     /* divisão inteira */
s = S % 60;       /* resto */

/* Soma dos minutos e cálculo do carry para graus */
M = m1 + m2 + c_m;
c_d = M / 60;     /* divisão inteira */
m = M % 60;       /* resto */

/* Soma dos graus */
d = d1 + d2 + c_d;

/* Impressão no formato pedido */
printf("%dd%dm%ds\n", d, m, s);

return 0;
}
Observações importantes sobre o programa:
  • Não há nenhum comando if/else; todo o ajuste de carry é feito por divisão inteira e operador módulo.
  • A máscara de leitura "%dd%dm%ds" aceita entradas como "20d50m37s" (sem espaços).
  • O programa funciona para inteiros (assumimos valores de minutos e segundos não negativos; se houver possibilidade de entradas inválidas, deveria haver validação — mas o enunciado pede sem condicionais).

Passo 8

Dicas práticas para usar na prova (como aplicar manualmente sem calculadora complexa):
  • Faça as somas coluna a coluna: segundos, anote total; divida por 60 para ver quantos minutos carregar (você pode subtrair 60 repetidamente até ficar <60 se não tiver como dividir com facilidade, mas em prova geralmente divisão por 60 é fácil).
  • Em papel, o passo “ \bmod 60” equivale a subtrair 60 vezes a parte inteira da divisão por 60.
  • Sempre mantenha as variáveis inteiras; nunca use aproximações reais/float para evitar erros de arredondamento.

Resposta

a) \displaystyle S = s_1+s_2,\quad c_m=\left\lfloor \dfrac{S}{60}\right\rfloor,\quad s=S\bmod 60,\quad M=m_1+m_2+c_m,\quad c_d=\left\lfloor \dfrac{M}{60}\right\rfloor,\quad m=M\bmod 60,\quad d=d_1+d_2+c_d.
b) Programa em C (leia duas entradas com "%dd%dm%ds" e use divisão inteira e módulo conforme o código fornecido no passo 7).

Exercícios relacionados