Une horloge analogique a 2 aiguilles *: heure et minute.
Ces aiguilles encerclent le cadran de l'horloge au fil du temps. Chaque rotation complète de l'aiguille des minutes entraîne 1 / 12ème de rotation de l'aiguille des heures. 2 tours complets de l'aiguille des heures signifient une journée complète.

Comme ces mains sont fixées au même point central et tournent autour de ce point, vous pouvez toujours calculer l'angle entre les mains. En fait, il y a 2 angles à tout moment; Un plus grand et un plus petit (parfois ils seront tous les deux égaux à 180, mais ce n'est pas important)

* Nos horloges hypothétiques n'ont pas de seconde main

Tâche

Étant donné une heure au format 24 heures, affichez le plus petit angle entre les mains, en degrés. Si les mains sont directement en face l'une de l'autre (comme à 6:00, 18:00etc.), sortie 180

Règles

Entrée peut être considéré comme: - Un séparateur de chaîne séparé: 6:32, 14.26 - 2 valeurs séparées, des chaînes ou des ints: 6, 32, 14, 26 - Une matrice de 2 valeurs, des chaînes ou des ints: [6, 32],[14, 26]

Vous pouvez également éventuellement spécifier que votre réponse nécessite des entrées être rembourré à 2 chiffres ( en supposant que vous prenez des chaînes), à savoir: 06:32, 06, 32,[06, 32]

Vous pouvez également en option inverser l'ordre des entrées, en minutes , puis une heure, à savoir: 32:6, 32, 6,[26, 14]

L'heure sera une valeur entière entre 0et 23(inclus) La minute sera une valeur entière entre 0et 59(inclus)

Vous pouvez supposer que l'aiguille des minutes s'accroche par incréments de 6 degrés le long du visage (une position régulièrement espacée pour chaque valeur de minute)
Vous pouvez supposer que l'aiguille des heures s'accroche par incréments de 0,5 degré le long du visage (une position également chaque valeur minute par valeur heure)

La sortie doit être donnée en degrés, pas en radians. Vous pouvez inclure un suivi .0pour les nombres entiers

Notation

C'est du golf de code donc le moins d'octets dans chaque langue gagne!

Cas de 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 octets

Prend les entrées comme (h)(m).

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

Essayez-le en ligne!

Comment?

Au lieu de travailler directement dans la plage , nous définissons une variable temporaire dans la plage :$[0..360]$$x$$[0..4]$

L'angle en degrés est donné par:

Cependant, la formule est implémentée un peu différemment dans le code JS, car nous voulons certainement éviter d'utiliser le long Math.abs()et le Math.min().

Au lieu de calculer la valeur absolue, nous une valeur positive dans en calculant:$[0..12]$

Et au lieu de calculer le minimum, nous déterminons dans quel cas nous sommes en faisant simplement un ET au niveau du bit avec - et c'est pourquoi nous avons choisi un intervalle limité par une puissance de en premier lieu.$2$$2$

Gelée , 14 12 octets

ד<¿‘Iæ%Ø°AH

Essayez-le en ligne!

Un lien monadique qui prend le temps comme une liste de deux entiers: heure, minute.

Merci à @JonathanAllan d'avoir économisé 2 octets!

Explication

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

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

Accepte deux entrées d'heures suivies de minutes. Utilise la même méthode que cette réponse

Essayez-le sur MATL Online

Explication

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

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

Essayez-le en ligne!

version non golfée:

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

L'argument de la fonction # = {h,m}contient l'heure et la minute. Cette longueur deux liste est interprétée comme un vecteur et le point-produit {30,-5.5}est calculé: #.{30,-5.5} = 30*h-5.5*m. Ensuite, nous calculons le module symétrique de 360 ​​en Mod[#.{30,-5.5}, 360, -180]donnant un angle dans l'intervalle -180 .. + 180. Absen prend la valeur absolue.

Comme tous les opérateurs impliqués sont linéaires, nous pouvons multiplier et diviser tous les nombres apparaissant comme ils sont les plus pratiques. En retirant un facteur de 5l'expression et en divisant tous les nombres de l'expression par 5, le nombre d'octets est minimisé.

Alchimiste , 134 octets

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

Essayez-le en ligne!

Explication

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

La configuration initiale. Entrer les heures et les minutes dans het m, définit l'angle actuel dà 360 degrés (720 demi-degrés), configure apour calculer l'angle principal et définit l'indicateur de sortie.

h->60d
m+11d->

Chaque heure ajoute 30 degrés et chaque minute soustrait 5,5 degrés.

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

Bien que l' rindicateur (inverse) ne soit pas défini, chaque datome doit déplacer un aatome vers b. Cela se produit après que toutes les minutes soient épuisées, pour éviter une "condition de course". Lorsqu'il ne reste plus d' aatomes, réglez-le rpour inverser ce flux.

Notez que cette deuxième règle peut se déclencher plusieurs fois et peut même se déclencher avant la règle de configuration initiale. Cela ne nuit à rien, il n'est donc pas nécessaire de prévenir cela. La 0xcondition gère un cas de bord: lorsque l'entrée est 6:00, il n'y a pas d' aatomes lorsque le programme se termine, mais il y a des xatomes si le résultat final est d'au moins 1 degré.

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

L'inverse: lorsque l'angle signé est supérieur à 180 degrés, déplacez les batomes vers apour diminuer l'angle de sortie. Arrêtez de reculer lorsque l'angle atteint "360".

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

Lorsque tous les atomes sont épuisés, divisez par 2 pour obtenir l'angle de sortie.

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

Après cela, effectuez une sortie exactement une fois en utilisant l' findicateur de la configuration initiale.

Python 3.8 (pré-version) , 45 43 octets

-2 octets grâce à Erik .

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

Essayez-le en ligne!

h%12- heure au format 12 heures
h%12*30- angle de l'aiguille des heures à l'heure entière
m/2- angle de l'aiguille des heures déplacée en mminutes
h%12*30+m/2- position actuelle de l'aiguille des heures en tant qu'angle
m*6- angle de l'aiguille des minutes ( 360°/60 = 6°)

Stax , 15 octets

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

Exécuter et déboguer

• m = nombre de minutes depuis minuit
• d = 5.5 * m
• Le résultat est min(d % 360, -d % 360).

C # (Visual C # Interactive Compiler) , 47 45 octets

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

Essayez-le en ligne!

Fusain , 22 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Prend l'entrée comme deux entiers. Explication:

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

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

Essayez-le en ligne!

Utilise quelques astuces volées dans d'autres réponses et calcule

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

Python 3 , 40 octets

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

Essayez-le en ligne!

h*30- angle entre midi et l'heure hoù la minute est 0; si l'heure est égale ou supérieure à 12, cet angle peut être égal ou supérieur à 360 °
m*6- angle entre midi et l'aiguille des minutes
m*.5- angle que l'aiguille des heures avance de l'heure complète après les mminutes (par exemple: s'il est 4 h 24, l'aiguille des heures a avancé de 12 degrés par rapport à la position où elle se trouvait à 4 heures)
h*30-m*5.5- l'un des deux angles entre l'aiguille des heures et l'aiguille des minutes; le coefficient de mest 5.5parce que m*6-m*.5=m*5.5; ce n'est toujours pas la réponse car il peut s'agir d'une valeur supérieure à 360 ° (ex: si h,m=13,0) ou inférieure à 0 ° (ex: si h,m=12,30)
(h*30-m*5.5)%360- ce modulo prend en compte les cas où la valeur calculée ci-dessus n'est pas comprise entre 0 et 360 °; ce n'est toujours pas la réponse car ce pourrait être l'amplificateur des deux angles, alors que nous voulons le plus étroit
180-abs(180-(h*30-m*5.5)%360)- c'est le résultat final; la règle générale est celle qui x-abs(x-y)équivaut à min(y,x-y), ce qui donnerait le résultat correct

Tcl , 71 74 59 54 octets

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

Essayez-le en ligne!

enregistré 5 octets en utilisant une expression lambda

Python 3, 58 57 octets

-1 / -2 Merci à @Shaggy

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

Implémentation naïve, prend les entrées sous la forme de [6,32]. Certains octets peuvent probablement être supprimés de la dernière ligne en particulier.

Python 2, 52 50 octets

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

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

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

Essayez-le en ligne!

Prend l'entrée en heures suivie de minutes sur une ligne distincte car elle a économisé quelques octets.

[R], 45 octets

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

Japt , 16 octets

*FÑ aV*5½
mUa360

Essayez-le

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

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

Essayez-le en ligne! (6:32)

Prend l'entrée comme h, m sur la pile.

Explication

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 octets

60*+5.5*D(‚360%ß

Prend des heures comme première entrée, des minutes comme seconde.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

Implémente essentiellement la formule suivante:

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 octets

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