Un reloj analógico tiene 2 manecillas *: hora y minuto.
Estas manecillas rodean la esfera del reloj a medida que pasa el tiempo. Cada rotación completa de la manecilla de minutos da como resultado 1/12 de una rotación de la manecilla de hora. 2 rotaciones completas de la manecilla de la hora significa un día completo.

Como estas manos se fijan en el mismo punto central y giran alrededor de ese punto, siempre puede calcular el ángulo entre las manos. De hecho, hay 2 ángulos en cualquier momento dado; Uno más grande y uno más pequeño (a veces ambos equivalen a 180, pero eso no es importante)

* Nuestros relojes hipotéticos no tienen segundero

Tarea

Dado un tiempo en formato de 24 horas, muestre el ángulo más pequeño entre las manos, en grados. Si las manecillas están directamente opuestas entre sí (como en 6:00, 18:00etc.) salida 180

Reglas

De entrada puede ser tomado como: - Un delimitador separa cadena: 6:32, 14.26 - 2 valores separados, cadenas o enteros: 6, 32, 14, 26 - Una matriz de 2 valores, cadenas o enteros: [6, 32],[14, 26]

También puede especificar opcionalmente que su respuesta requiere insumos ser acolchada a 2 dígitos (suponiendo que toma cuerdas), es decir: 06:32, 06, 32,[06, 32]

También puede revertir opcionalmente el orden de las entradas, teniendo minutos luego horas, es decir: 32:6, 32, 6,[26, 14]

La hora será un valor entero entre 0y 23(inclusive) El minuto será un valor entero entre 0y 59(inclusive)

Puede suponer que la manecilla de los minutos se ajusta a incrementos de 6 grados a lo largo de la cara (una posición espaciada uniformemente para cada valor de minuto)
Puede suponer que la manecilla de la hora se ajusta a incrementos de 0.5 grados a lo largo de la cara (una posición espaciada uniformemente para valor de cada minuto por valor de hora)

La salida debe darse en grados, no en radianes. Puede incluir un final.0 para números enteros

Tanteo

Este es el código de golf, por lo que gana menos bytes en cada idioma .

Casos de prueba

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

Pruébalo en línea!

¿Cómo?

En lugar de trabajar directamente en el rango $[0..360]$ , definimos una variable temporal $x$ en el rango $[0..4]$ :

El ángulo en grados viene dado por:

Sin embargo, la fórmula se implementa de manera un poco diferente en el código JS, ya que definitivamente queremos evitar el uso de los largos Math.abs()y Math.min().

En lugar de calcular el valor absoluto, forzamos un valor positivo en $[0..12]$ calculando:

Y en lugar de calcular el mínimo, determinamos en qué caso estamos simplemente haciendo un bit Y con $2$ , y es por eso que elegimos un intervalo limitado por una potencia de $2$ en primer lugar.

Jalea , 14 12 bytes

ד<¿‘Iæ%Ø°AH

Pruébalo en línea!

Un enlace monádico que toma el tiempo como una lista de dos enteros: hora, minuto.

¡Gracias a @JonathanAllan por guardar 2 bytes!

Explicación

ד<¿‘        | 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<

Acepta dos entradas de horas seguidas de minutos. Utiliza el mismo método que esta respuesta

Pruébalo en MATL Online

Explicación

      % 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]&

Pruébalo en línea!

versión sin golf:

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

El argumento de la función es # = {h,m} contiene la hora y el minuto. Esta lista longitud de dos se interpreta como un vector y el punto-producto con {30,-5.5}se calcula: #.{30,-5.5} = 30*h-5.5*m. Luego calculamos el módulo simétrico de 360 Mod[#.{30,-5.5}, 360, -180]dando un ángulo en el intervalo -180 .. + 180.Abstoma el valor absoluto del mismo.

Como todos los operadores involucrados son lineales, podemos multiplicar y dividir todos los números que aparecen, sin embargo, son más convenientes. Al extraer un factor de 5la expresión y dividir todos los números en la expresión por 5, el conteo de bytes se minimiza.

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

Pruébalo en línea!

Explicación

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

Configuración inicial. Ingresa horas y minutos en hy m, establece el ángulo actual den 360 grados (720 medios grados), se configura apara calcular el ángulo principal y establece el indicador de salida.

h->60d
m+11d->

Cada hora suma 30 grados, y cada minuto resta 5,5 grados.

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

Si bien el rindicador (inverso) no está establecido, cada dátomo debe mover un aátomo a b. Esto ocurre después de que los minutos se hayan agotado, para evitar una "condición de carrera". Cuando no haya átomos, configure rpara invertir este flujo.

Tenga en cuenta que esta segunda regla puede activarse varias veces e incluso puede activarse antes de la regla de configuración inicial. Esto no daña nada, por lo que no hay necesidad de evitarlo. La 0xcondición maneja un caso límite: cuando la entrada es 6:00, no hay aátomos cuando el programa termina, pero hay xátomos si el resultado final es al menos 1 grado.

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

Lo contrario: cuando el ángulo con signo es mayor de 180 grados, mueva los bátomos hacia apara disminuir el ángulo de salida. Deje de invertir cuando el ángulo alcance "360".

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

Cuando se agoten todos los átomos en grados, divídalos entre 2 para obtener el ángulo de salida.

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

Una vez hecho esto, imprima exactamente una vez utilizando el findicador de la configuración inicial.

Python 3.8 (prelanzamiento) , 45 43 bytes

-2 bytes gracias a Erik .

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

Pruébalo en línea!

h%12- hora en formato de 12 horas
h%12*30- ángulo de la manecilla de la hora a la hora completa
m/2- ángulo de la manecilla de la hora movida en mminutos
h%12*30+m/2- posición actual de la manecilla de la hora como un ángulo
m*6- ángulo de la manecilla de los minutos ( 360°/60 = 6°)

Stax , 15 bytes

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

Ejecutar y depurarlo

• m = cantidad de minutos desde la medianoche
• d = 5.5 * m
• El resultado es min(d % 360, -d % 360).

C # (compilador interactivo de Visual C #) , 47 45 bytes

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

Pruébalo en línea!

Carbón de leña , 22 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Toma la entrada como dos enteros. Explicación:

             Ｎ          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

Pruébalo en línea!

Utiliza algunos trucos robados de otras respuestas y 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)

Pruébalo en línea!

h*30- ángulo entre el mediodía y la hora hcuando son los minutos 0; si la hora es igual o mayor que 12, este ángulo puede ser igual o mayor que 360 ​​°
m*6- ángulo entre el mediodía y la manecilla de los minutos
m*.5- ángulo la manecilla de la hora avanzó desde la hora completa después de mminutos (por ejemplo: si son las 4:24, la manecilla de la hora avanzó 12 grados desde la posición en que estaba a las 4 en punto)
h*30-m*5.5, uno de los dos ángulos entre la manecilla de la hora y la manecilla de los minutos; el coeficiente para mes 5.5porque m*6-m*.5=m*5.5; esta todavía no es la respuesta porque puede ser un valor mayor que 360 ​​° (por ejemplo: if h,m=13,0) o menor que 0 ° (por ejemplo: if h,m=12,30)
(h*30-m*5.5)%360- este módulo tiene en cuenta los casos en que el valor calculado anteriormente no está entre 0 y 360 °; esta todavía no es la respuesta porque podría ser el más amplio de los dos ángulos, mientras que queremos el más estrecho
180-abs(180-(h*30-m*5.5)%360): este es el resultado final; la regla general es que x-abs(x-y)es equivalente a min(y,x-y), lo que daría el resultado correcto

Tcl , 71 74 59 54 bytes

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

Pruébalo en línea!

ahorró 5 bytes usando una expresión lambda

Pitón 3, 58 57 Bytes

-1 / -2 Gracias a @Shaggy

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

Implementación ingenua, toma entrada en forma de [6,32] . Algunos bytes probablemente se pueden eliminar de la última línea 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-$_

Pruébalo en línea!

Toma la entrada como horas seguidas de minutos en una línea separada porque ahorró algunos bytes.

[R], 45 bytes

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

Japt , 16 bytes

*FÑ aV*5½
mUa360

Intentalo

*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

Pruébalo en línea! (6:32)

Toma entrada como h, m en la pila.

Explicación

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%ß

Toma horas como primera entrada, minutos como segunda.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

Básicamente implementa la siguiente 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))}