Un orologio analogico ha 2 lancette *: ora e minuti.
Queste lancette circondano il quadrante dell'orologio con il passare del tempo. Ogni rotazione completa della lancetta dei minuti determina 1/12 di rotazione della lancetta delle ore. 2 rotazioni complete della lancetta delle ore indicano un giorno intero.

Poiché queste lancette sono fissate sullo stesso punto centrale e ruotano attorno a quel punto, puoi sempre calcolare l'angolo tra le lancette. In effetti ci sono 2 angoli in un dato momento; Uno più grande e uno più piccolo (a volte saranno entrambi uguali a 180, ma non è importante)

* I nostri ipotetici orologi non hanno lancette dei secondi

Compito

Dato un tempo nel formato 24 ore, emette l'angolo più piccolo tra le mani, in gradi. Se le mani sono direttamente opposte (come ad esempio a 6:00, 18:00ecc.), Uscite 180

Regole

Ingresso può essere presa come: - Un delimitatore separato stringa: 6:32, 14.26 - 2 valori separati, stringhe o interi: 6, 32, 14, 26 - Un array di 2 valori, stringhe o interi: [6, 32],[14, 26]

Si può anche opzionalmente specificare che la risposta richiede ingressi essere imbottito a 2 cifre (supponendo che si prende le stringhe), vale a dire: 06:32,06, 32 ,[06, 32]

Si può anche opzionalmente invertire l'ordine degli ingressi, prendendo minuto poi ore, cioè: 32:6, 32, 6,[26, 14]

L'ora sarà un valore intero compreso tra 0e 23(compreso) Il minuto sarà un valore intero compreso tra 0e 59(compreso)

Si può presumere che la lancetta dei minuti scatti ad incrementi di 6 gradi lungo la faccia (una posizione a spaziatura uniforme per ciascun valore dei minuti)
Si può presumere che la lancetta delle ore scatti ad incrementi di 0,5 gradi lungo la faccia (una posizione a spaziatura uniforme per valore ogni minuto valore orario)

L'output deve essere espresso in gradi, non in radianti. Puoi includere un finale.0 per numeri interi

punteggio

Si tratta di code-golf quindi vince il minor numero di byte in ogni lingua !

Casi test

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 byte

Accetta input come (h)(m).

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

Provalo online!

Come?

Invece di lavorare direttamente nell'intervallo $[0..360]$ , definiamo una variabile temporanea $x$ nell'intervallo$[0..4]$ :

L'angolo in gradi è dato da:

Tuttavia, la formula è implementata in modo leggermente diverso nel codice JS, poiché vogliamo assolutamente evitare di usare il lungo Math.abs()e Math.min().

Invece di calcolare il valore assoluto, forziamo un valore positivo in $[0..12]$ calcolando:

E invece di calcolare il minimo, determiniamo in quale caso stiamo semplicemente facendo un AND bit a bit con $2$ - ed è per questo che abbiamo scelto un intervallo limitato da una potenza di $2$ in primo luogo.

Gelatina , 14 12 byte

ד<¿‘Iæ%Ø°AH

Provalo online!

Un collegamento monadico che prende il tempo come un elenco di due numeri interi: ora, minuto.

Grazie a @JonathanAllan per aver salvato 2 byte!

Spiegazione

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

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

Accetta due input di ore seguiti da minuti. Utilizza lo stesso metodo di questa risposta

Provalo su MATL Online

Spiegazione

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

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

Provalo online!

versione non golfata:

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

L'argomento della funzione # = {h,m}contiene l'ora e il minuto. Questo elenco lunghezza due viene interpretato come vettore e il dot-prodotto {30,-5.5}è calcolata: #.{30,-5.5} = 30*h-5.5*m. Quindi calcoliamo il modulo simmetrico di 360 con Mod[#.{30,-5.5}, 360, -180]un angolo compreso nell'intervallo -180 .. + 180. Absprende il suo valore assoluto.

Poiché tutti gli operatori coinvolti sono lineari, possiamo moltiplicare e dividere tutti i numeri visualizzati, tuttavia sono i più convenienti. Estraendo un fattore 5dall'espressione e dividendo tutti i numeri nell'espressione per 5, il conteggio dei byte viene ridotto al minimo.

Alchimista , 134 byte

_->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

Provalo online!

Spiegazione

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

Configurazione iniziale. Inserisce ore e minuti in he m, imposta l'angolo corrente dsu 360 gradi (720 gradi mezzo), imposta aper calcolare l'angolo principale e imposta il flag di output.

h->60d
m+11d->

Ogni ora aggiunge 30 gradi e ogni minuto sottrae 5,5 gradi.

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

Mentre il rflag (inverso) non è impostato, ogni datomo dovrebbe spostarsi su un aatomo b. Ciò si verifica dopo che i minuti sono stati esauriti, per evitare una "condizione di gara". Quando non ci sonoa atomi rimanenti, impostarer per invertire questo flusso.

Si noti che questa seconda regola può essere attivata più volte e può persino essere attivata prima della regola di configurazione iniziale. Questo non danneggia nulla, quindi non è necessario prevenirlo. Il0x condizione gestisce un caso limite: quando l'ingresso è 6:00, non ci sono aatomi quando il programma termina, ma ci sono xatomi se il risultato finale è di almeno 1 grado.

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

Il contrario: quando l'angolo con segno è maggiore di 180 gradi, spostati b atomi aper ridurre l'angolo in uscita. Interrompere l'inversione quando l'angolo raggiunge "360".

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

Quando tutti gli atomi di grado sono esauriti, dividere per 2 per ottenere l'angolo in uscita.

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

Fatto ciò, emettere esattamente una volta usando il fflag dalla configurazione iniziale.

Python 3.8 (pre-release) , 45 43 byte

-2 byte grazie a Erik .

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

Provalo online!

h%12- ora nel formato delle 12 ore
h%12*30- angolo della lancetta delle ore sull'intera ora
m/2- angolo della lancetta delle ore spostata in mminuti
h%12*30+m/2- posizione attuale della lancetta delle ore come angolo
m*6- angolo della lancetta dei minuti ( 360°/60 = 6°)

Stax , 15 byte

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

Esegui ed esegui il debug

• m = numero di minuti dalla mezzanotte
• d = 5.5 * m
• Il risultato è min(d % 360, -d % 360).

C # (compilatore interattivo Visual C #) , 47 45 byte

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

Provalo online!

Carbone , 22 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Accetta input come due numeri interi. Spiegazione:

             Ｎ          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 byte

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

Provalo online!

Usa alcuni trucchi rubati da altre risposte e calcola

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

Python 3 , 40 byte

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

Provalo online!

h*30- angolo tra mezzogiorno e l'ora in hcui il minuto è 0; se l'ora è uguale o maggiore di 12, questo angolo può essere uguale o maggiore di 360 °
m*6- angolo tra mezzogiorno e la lancetta dei minuti
m*.5- angolo della lancetta delle ore spostata in avanti rispetto all'ora intera dopo i mminuti (ad esempio: se è 4:24, la lancetta delle ore si spostò in avanti di 12 gradi rispetto alla posizione in cui si trovava alle 4)
h*30-m*5.5- uno dei due angoli tra la lancetta delle ore e la lancetta dei minuti; il coefficiente per mè 5.5perché m*6-m*.5=m*5.5; questa non è ancora la risposta perché può essere un valore maggiore di 360 ° (es: ifh,m=13,0 ) o inferiore a 0 ° (es: seh,m=12,30 )
(h*30-m*5.5)%360- questo modulo tiene conto dei casi in cui il valore calcolato sopra non è compreso tra 0 e 360 ​​°; questa non è ancora la risposta perché potrebbe essere la più ampia delle due angolazioni, mentre noi vogliamo il più stretto
180-abs(180-(h*30-m*5.5)%360)- questo è il risultato finale; la regola generale x-abs(x-y)è equivalente a min(y,x-y), che darebbe il risultato corretto

Tcl , 71 74 59 54 byte

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

Provalo online!

salvato 5 byte usando un'espressione lambda

Python 3, 58 57 byte

-1 / -2 Grazie a @Shaggy

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

Implementazione ingenua, accetta input sotto forma di [6,32] . Alcuni byte possono probabilmente essere rasati dall'ultima riga in particolare.

Python 2, 52 50 byte

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

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

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

Provalo online!

Accetta input come ore seguite da minuti su una riga separata perché ha salvato alcuni byte.

[R], 45 byte

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

Japt , 16 byte

*FÑ aV*5½
mUa360

Provalo

*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 byte

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

Provalo online! (06:32)

Accetta input come h, m in pila.

Spiegazione

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 byte

60*+5.5*D(‚360%ß

Richiede ore come primo input, minuti come secondo.

Provalo online o verifica tutti i casi di test .

Spiegazione:

Implementa sostanzialmente la seguente formula:

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 byte

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