Um relógio analógico tem 2 ponteiros *: hora e minuto.
Esses ponteiros circulam o mostrador do relógio à medida que o tempo passa. Cada rotação completa do ponteiro dos minutos resulta em 1/12 de uma rotação do ponteiro das horas. 2 rotações completas do ponteiro das horas significam um dia inteiro.

Como essas mãos são fixadas no mesmo ponto central e giram em torno desse ponto, você sempre pode calcular o ângulo entre as mãos. De fato, existem 2 ângulos a qualquer momento; Um maior e outro menor (às vezes ambos são iguais a 180, mas isso não é importante)

* Nossos relógios hipotéticos não têm ponteiros de segundos

Tarefa

Dada uma hora no formato de 24 horas, produza o ângulo menor entre as mãos, em graus. Se os ponteiros estiverem diretamente opostos um ao outro (como em 6:00, 18:00etc), produza 180

Regras

De entrada pode ser feita como: - Um delimitador separados cadeia: 6:32, 14.26 - 2 valores separados, cordas ou ints: 6, 32, 14, 26 - Uma matriz de 2 valores, cordas ou ints: [6, 32],[14, 26]

Você também pode especificar opcionalmente que sua resposta requer entradas ser acolchoado para 2 dígitos (supondo que você tomar cordas), ou seja: 06:32, 06, 32,[06, 32]

Também pode inverter, opcionalmente, o ordem das entradas, tendo minutos, em seguida hora, ou seja: 32:6, 32, 6,[26, 14]

Hora será um valor inteiro entre 0e 23(inclusive) Minuto será um valor inteiro entre 0e 59(inclusive)

Você pode assumir que o ponteiro dos minutos se ajusta a incrementos de 6 graus ao longo da face (uma posição espaçada igualmente para cada valor de minuto)
Você pode assumir que o ponteiro dos minutos se ajusta a incrementos de 0,5 graus ao longo da face (uma posição espaçada igualmente para valor de cada minuto por valor de hora)

A saída deve ser dada em graus, não em radianos. Você pode incluir um final .0para números inteiros

Pontuação

Isso é código-golfe, e o menor número de bytes em cada idioma vence!

Casos de teste

Input: 06:32
Output: 4

Input: 06:30
Output: 15

Input: 18:32
Output: 4

Input: 06:01
Output: 174.5

Input: 00:00
Output: 0

Input: 00:01
Output: 5.5

Input: 12:30
Output: 165

Input: 6:00
Output: 180

Input: 23:59
Output: 5.5

JavaScript (ES6),  41 40  39 bytes

Toma entradas como (h)(m).

h=>m=>((x=4+h/3-m*.55/9)&2?12-x:x)%4*90

Experimente online!

Quão?

Em vez de trabalhar diretamente no intervalo , definimos uma variável temporária no intervalo :$[0..360]$$x$$[0..4]$

O ângulo em graus é dado por:

No entanto, a fórmula é implementada de maneira um pouco diferente no código JS, pois definitivamente queremos evitar o uso do extenso Math.abs()e Math.min().

Em vez de calcular o valor absoluto, forçamos um valor positivo em calculando:$[0..12]$

E, em vez de calcular o mínimo, determinamos em que caso estamos simplesmente fazendo um AND bit a bit com - e é por isso que escolhemos um intervalo limitado por uma potência de em primeiro lugar.$2$$2$

Geléia , 14 12 bytes

ד<¿‘Iæ%Ø°AH

Experimente online!

Um link monádico que leva o tempo como uma lista de dois números inteiros: hora, minuto.

Obrigado a @ JonathanAllan por salvar 2 bytes!

Explicação

ד<¿‘        | Multiply hour by by 60 and minute by 11
     I       | Find difference
      æ%Ø°   | Symmetric mod 360 [equivalent to (x + 360) mod 720 - 360]
          A  | Absolute
           H | Half

MATL, 18 bytes

30*i5.5*-t360-|hX<

Aceita duas entradas de horas seguidas de minutos. Usa o mesmo método que esta resposta

Experimente no MATL Online

Explicação

      % Implicitly grab first input (hours)
30*   % Multiply by 30
i     % Explicitly grab second input (minutes)
5.5*  % Multiply by 5.5
-     % Take the difference
t     % Duplicate the result
360-  % Subtract 360
|     % Take the absolute value
h     % Horizontally concatenate
X<    % Determine the minimum value
      % Implicitly display the result

Wolfram Language (Mathematica) , 30 29 28 bytes

5Abs@Mod[#.{6,-1.1},72,-36]&

Experimente online!

versão não destruída:

Abs[Mod[#.{30,-5.5}, 360, -180]] &

O argumento da função está # = {h,m}contendo a hora e o minuto. Esta lista comprimento de dois é interpretado como um vetor e o produto dot com {30,-5.5}é calculado: #.{30,-5.5} = 30*h-5.5*m. Depois calculamos o módulo simétrico de 360 ​​com Mod[#.{30,-5.5}, 360, -180]um ângulo no intervalo -180 .. + 180. Abstoma o valor absoluto do mesmo.

Como todos os operadores envolvidos são lineares, podemos multiplicar e dividir todos os números que aparecem, mas são mais convenientes. Ao extrair um fator da 5expressão e dividir todos os números na expressão por 5, a contagem de bytes é minimizada.

Alquimista , 134 bytes

_->In_h+In_m+720d+360a+f
h->60d
m+11d->
0m+d+a+0r->b
0a+0x->r
d+b+r->r+a
r+0b->
b+0d+0h+0y->5y
b+0d+5y->x
0b+0d+f->Out_x+Out_"."+Out_y

Experimente online!

Explicação

_->In_h+In_m+720d+360a+f

Configuração inicial. Introduz horas e minutos em he m, define o ângulo atual dpara 360 graus (720 meio graus), configura apara calcular o ângulo principal e define o sinalizador de saída.

h->60d
m+11d->

Cada hora adiciona 30 graus e cada minuto subtrai 5,5 graus.

0m+d+a+0r->b
0a+0x->r

Enquanto o rsinalizador (reverso) não estiver definido, cada dátomo deve mover um aátomo para b. Isso ocorre depois que os minutos são esgotados, para evitar uma "condição de corrida". Quando não houver aátomos restantes, defina rpara reverter esse fluxo.

Observe que esta segunda regra pode ser disparada várias vezes e até mesmo antes da regra de configuração inicial. Isso não prejudica nada, portanto não há necessidade de evitar isso. A 0xcondição lida com um caso de borda: quando a entrada é 6:00, não há aátomos quando o programa termina, mas existem xátomos se o resultado final for de pelo menos 1 grau.

d+b+r->r+a
r+0b->

O inverso: quando o ângulo assinado for maior que 180 graus, mova os bátomos para apara diminuir o ângulo para a saída. Pare de inverter quando o ângulo atingir "360".

b+0d+0h+0y->5y
b+0d+5y->x

Quando todos os átomos em grau estiverem esgotados, divida por 2 para obter o ângulo de saída.

0b+0d+f->Out_x+Out_"."+Out_y

Depois disso, imprima exatamente uma vez usando o fsinalizador da configuração inicial.

Python 3.8 (pré-lançamento) , 45 43 bytes

-2 bytes graças a Erik .

lambda h,m:min(x:=abs(h%12*30-m*5.5),360-x)

Experimente online!

h%12- hora no formato de 12 horas
h%12*30- ângulo do ponteiro das horas em toda a hora
m/2- ângulo do ponteiro das horas em mminutos
h%12*30+m/2- posição atual do ponteiro das horas como ângulo
m*6- ângulo do ponteiro dos minutos ( 360°/60 = 6°)

Stax , 15 bytes

Ç╢e╛╦¡uøßmì♪║└├

Execute e depure

• m = número de minutos desde a meia-noite
• d = 5.5 * m
• O resultado é min(d % 360, -d % 360).

C # (compilador interativo do Visual C #) , 47 45 bytes

h=>m=>(h=(360+h%12*30-m*5.5)%360)<180?h:360-h

Experimente online!

Carvão , 22 bytes

Ｉ↔⁻¹⁸⁰﹪⁻׳⁰⁺⁶Ｎ×⁵·⁵Ｎ³⁶⁰

Experimente online! Link é a versão detalhada do código. Aceita entrada como dois números inteiros. Explicação:

             Ｎ          First input
           ⁺⁶           Plus literal 6
        ׳⁰             Multiplied by literal 30
       ⁻                Minus
                  Ｎ     Second input
              ×⁵·⁵      Multiplied by literal 5.5
      ﹪            ³⁶⁰  Modulo literal 360
  ⁻¹⁸⁰                  Subtracted from literal 180
 ↔                      Absolute value
Ｉ                       Cast to string
                        Implicitly print

Perl 6 , 28 bytes

((*/3-*/9*.55+2)%4-2).abs*90

Experimente online!

Usa alguns truques roubados de outras respostas e calcula

r = abs((h/3 - m/9*0.55 + 2) % 4 - 2) * 90
  = abs((h*30 - m*5.5 + 180) % 360 - 180)

Python 3 , 40 bytes

lambda h,m:180-abs(180-(h*30-m*5.5)%360)

Experimente online!

h*30- ângulo entre o meio dia e a hora hem que o minuto é 0; se a hora for igual ou superior a 12, este ângulo poderá ser igual ou superior a 360 °
m*6- ângulo entre o meio-dia e o ponteiro dos minutos
m*.5- ângulo que o ponteiro das horas avançou a partir da hora inteira após mminutos (por exemplo: se for 4:24, o ponteiro das horas avançou 12 graus a partir da posição em que estava às 4 horas)
h*30-m*5.5- um dos dois ângulos entre o ponteiro das horas e o ponteiro dos minutos; o coeficiente para mé 5.5porque m*6-m*.5=m*5.5; ainda não é a resposta, pois pode ser um valor maior que 360 ​​° (por exemplo: se h,m=13,0) ou menor que 0 ° (por exemplo: se h,m=12,30)
(h*30-m*5.5)%360- este módulo leva em consideração os casos em que o valor calculado acima não está entre 0 e 360 ​​°; ainda não é a resposta, porque poderia ser o maior dos dois ângulos, enquanto queremos o mais estreito
180-abs(180-(h*30-m*5.5)%360)- esse é o resultado final; a regra geral é que x-abs(x-y)é equivalente a min(y,x-y), o que daria o resultado correto

Tcl , 71 74 59 54 bytes

{{h m {x (60*$h-$m*11)%720}} {expr min($x,720-$x)/2.}}

Experimente online!

salvou 5 bytes usando uma expressão lambda

Python 3, 58 57 bytes

-1 / -2 Graças a @Shaggy

h,m=eval(input())
x=(30*h-5.5*m)
print(abs(min(x,360-x)))

Implementação ingênua, recebe entrada na forma de [6,32]. Alguns bytes provavelmente podem ser removidos da última linha, especialmente.

Python 2, 52 50 bytes

h,m=input()
x=(30*h-5.5*m)
print abs(min(x,360-x))

Perl 5 -MList::Util=min -p , 37 bytes

$_=abs<>*5.5-$_%12*30;$_=min$_,360-$_

Experimente online!

Recebe a entrada como horas seguidas de minutos em uma linha separada, pois salvou alguns bytes.

[R], 45 bytes

 function(h,m)min(t=(60*h+m)*5.5%%360,-t%%360)

Japonês , 16 bytes

*FÑ aV*5½
mUa360

Tente

*FÑ aV*5½     :Implicit input of integers U=h and V=m
*F            :Multiply U by 15
  Ñ           :Multiply by 2
    a         :Absolute difference with
     V*5½     :V multiplied by 5.5
mUa360        :Reassign to U
m             :Minimum of U and
 Ua360        :Absolute difference of U and 360

> <> , 17 bytes

b*$6a**-:0)12,-*n

Experimente online! (6:32)

Recebe a entrada como h, m na pilha.

Explicação

b*$6a**-:0)12,-*n
b*                Multiplies m by 11
  $               Swaps m & h
   6a**           Multiplies h by 60
       -          Subtracts m & h (v)
        :0)       Checks if v > 0 (b=0/1)
           12,-   Subtracts .5 from b (-.5/.5)
               *  Multiplies v by b (halve & abs)
                n Outputs result
b*                Errors

05AB1E , 16 bytes

60*+5.5*D(‚360%ß

Leva horas como primeira entrada, minutos como segundo.

Experimente online ou verifique todos os casos de teste .

Explicação:

Implementa basicamente a seguinte fórmula:

60*               # Multiply the (implicit) hours-input by 60
   +              # Add it to the (implicit) minutes-input
    5.5*          # Multiply it by 5.5
        D(‚       # Pair it with it's negative
           360%   # Take modulo-360 on both
               ß  # And then pop and push the minimum of the two
                  # (which is output implicitly as result)

Pyret, 59 bytes

{(h,m):x=(30 * h) - (m * 5.5)
num-abs(num-min(x,360 - x))}