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:
) e seja exibido na tela o valor da soma desses ângulos, também no formato grau, minuto e segundo.
| Ângulo 1: | 20d50m37s |
| Ângulo 2: | 7d43m42s |
| Soma...: | 28d34m19s |
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:
Passo 1
O enunciado pede duas coisas:
- (a) Elaborar um algoritmo que some dois ângulos dados no formato grau, minuto e segundo — isto é, soma de
ângulo s do tipo ) — usando apenas operações matemáticas, sem nenhuma lógica condicional. - (b) Implementar um programa em que o usuário entra com dois ângulos no formato máscara
e o programa exibe a soma também em .
Informações relevantes dadas:
- Cada ângulo é representado por três inteiros: grau ), minuto ) e segundo ).
- Convenções de unidade:
grau minutos e minuto segundos. - Exemplo do enunciado: somando ) e ) obtém-se ) — 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
, devemos “carregar” minutos. - Minutos somam-se entre si (mais o carry de segundos); se o total de minutos for maior ou igual a
, 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 ou o operador . - Vamos usar a ideia: dado o total de segundos
, o número de minutos a transportar é e os segundos finais são . Isso é somente aritmética, sem teste if/then.
Passo 3
Definir variáveis (nomes e significado):
- Para o primeiro ângulo: ).
- Para o segundo ângulo: ).
- Variáveis auxiliares de soma: ) para segundos totais, ) para minutos totais, ) para graus totais.
- Variáveis de carry (transportes): ) para minutos vindos dos segundos, ) para graus vindos dos minutos.
- Resultado final: ).
Passo 4
Fórmulas matemáticas (sem condicionais) — passo a passo derivado da lógica de carry:
- Somar os segundos:
- Calcular quantos minutos transportar a partir dos segundos (divisão inteira) e os segundos finais (resto):
(obs.:
. Use a forma disponível na linguagem que for usar.)
- Somar os minutos incluindo o carry dos segundos:
- Calcular quantos graus transportar a partir dos minutos e os minutos finais:
- Somar os graus incluindo o carry dos minutos:
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: ) e ).
Resultado:
) — 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 ).
- Passos:
- Calcule
- Calcule
- Calcule
- Calcule
- Calcule
- Calcule
- Calcule
- Calcule
- Saída: inteiros ) representando a soma no formato grau, minuto e segundo.
Explicação sobre como implementar
e
em programação:
- Em C (e em muitas linguagens), para inteiros positivos,
é simplesmente usando divisão inteira, e é . 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
, 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;
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
aceita entradas como (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
para ver quantos minutos carregar (você pode subtrair 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 “
” equivale a subtrair 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)
b) Programa em C (leia duas entradas com
e use divisão inteira e módulo conforme o código fornecido no passo 7).