Jam analog memiliki 2 tangan *: Jam dan menit.
Tangan-tangan ini melingkari wajah jam seiring berjalannya waktu. Setiap putaran penuh jarum menit menghasilkan 1/12 putaran jarum jam. 2 putaran penuh jarum jam menandakan satu hari penuh.

Karena tangan-tangan ini terpaku pada titik pusat yang sama, dan berputar di sekitar titik itu, Anda selalu dapat menghitung sudut antara kedua tangan. Bahkan ada 2 sudut pada waktu tertentu; Yang lebih besar, dan yang lebih kecil (kadang-kadang keduanya sama dengan 180, tapi itu tidak penting)

* Jam hipotetis kami tidak memiliki tangan kedua

Tugas

Diberi waktu dalam format 24 jam, menghasilkan sudut yang lebih kecil di antara kedua tangan, dalam derajat. Jika tangan saling berhadapan secara langsung (seperti pada 6:00, 18:00dll) keluaran 180

Aturan

Masukan dapat diambil sebagai: - Sebuah pembatas string dipisahkan: 6:32, 14.26 - 2 nilai terpisah, string atau int: 6, 32, 14, 26 - Sebuah array dari 2 nilai, string atau int: [6, 32],[14, 26]

Anda juga dapat opsional menentukan bahwa jawaban Anda membutuhkan input menjadi empuk untuk 2 digit (dengan asumsi Anda mengambil string), yaitu: 06:32, 06, 32,[06, 32]

Anda juga dapat opsional membalik urutan input, mengambil menit kemudian jam, yaitu: 32:6, 32, 6,[26, 14]

Jam akan menjadi nilai integer antara 0dan 23(inklusif) Menit akan menjadi nilai integer antara 0dan 59(inklusif)

Anda dapat mengasumsikan bahwa jarum menit menjepret ke kenaikan 6 derajat di sepanjang wajah (satu posisi dengan jarak yang sama untuk setiap nilai menit)
Anda dapat mengasumsikan bahwa jarum jam menjentikkan ke peningkatan 0,5 derajat di sepanjang wajah (satu posisi dengan jarak yang sama untuk setiap nilai menit per nilai jam)

Keluaran harus diberikan dalam derajat, bukan radian. Anda dapat menyertakan trailing .0untuk bilangan bulat

Mencetak gol

Ini adalah kode-golf sehingga byte paling sedikit di setiap bahasa menang!

Testcases

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

Mengambil input sebagai (h)(m).

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

Cobalah online!

Bagaimana?

Alih-alih bekerja secara langsung dalam rentang , kami mendefinisikan variabel sementara dalam rentang :$[0..360]$$x$$[0..4]$

Sudut dalam derajat diberikan oleh:

Namun, rumus diimplementasikan sedikit berbeda dalam kode JS, karena kami pasti ingin menghindari penggunaan yang panjang Math.abs()dan Math.min().

Alih-alih menghitung nilai absolut, kami memaksakan nilai positif dalam dengan menghitung:$[0..12]$

Dan alih-alih menghitung minimum, kita menentukan dalam hal apa kita dengan hanya melakukan bitwise DAN dengan - dan inilah mengapa kita memilih interval yang dibatasi oleh kekuatan di tempat pertama.$2$$2$

Jelly , 14 12 byte

ד<¿‘Iæ%Ø°AH

Cobalah online!

Tautan monadik yang menggunakan waktu sebagai daftar dua bilangan bulat: jam, menit.

Terima kasih kepada @JonathanAllan karena telah menghemat 2 byte!

Penjelasan

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

Menerima dua input jam diikuti menit. Menggunakan metode yang sama dengan jawaban ini

Cobalah di MATL Online

Penjelasan

      % 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

Bahasa Wolfram (Mathematica) , 30 29 28 byte

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

Cobalah online!

versi tanpa ungolfed:

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

Argumen fungsi # = {h,m}berisi jam dan menit. Daftar panjang-dua ini ditafsirkan sebagai vektor dan dot-produk dengan {30,-5.5}dihitung: #.{30,-5.5} = 30*h-5.5*m. Kemudian kita menghitung modulus simetris 360 dengan Mod[#.{30,-5.5}, 360, -180]memberikan sudut pada interval -180 .. + 180. Absmengambil nilai absolut darinya.

Karena semua operator yang terlibat bersifat linier, kami dapat melipatgandakan dan membagi semua angka yang muncul namun paling nyaman. Dengan menarik faktor 5keluar dari ekspresi dan membagi semua angka dalam ekspresi dengan 5, byte-count diminimalkan.

Alchemist , 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

Cobalah online!

Penjelasan

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

Pengaturan awal. Input jam dan menit ke hdan m, atur sudut saat ini dmenjadi 360 derajat (720 setengah derajat), atur auntuk menghitung sudut utama, dan atur bendera keluaran.

h->60d
m+11d->

Setiap jam menambah 30 derajat, dan setiap menit mengurangi 5,5 derajat.

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

Sementara rbendera (mundur) tidak diatur, masing-masing datom harus memindahkan satu aatom ke b. Ini terjadi setelah semua menit habis, untuk menghindari "kondisi balapan". Ketika tidak ada aatom yang tersisa, atur runtuk membalikkan aliran ini.

Perhatikan bahwa aturan kedua ini dapat memicu beberapa kali, dan bahkan dapat memicu sebelum aturan pengaturan awal. Ini tidak membahayakan apa pun, jadi tidak perlu mencegah ini. The 0xKondisi menangani kasus tepi: ketika input adalah 06:00, tidak ada aatom ketika program berakhir, tetapi ada xatom jika hasil akhir setidaknya 1 derajat.

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

Kebalikannya: ketika sudut yang ditandatangani lebih besar dari 180 derajat, pindahkan batom ke auntuk menurunkan sudut ke keluaran. Berhenti membalik ketika sudut mencapai "360".

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

Ketika semua atom berderajat habis, bagi 2 untuk mendapatkan sudut keluaran.

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

Setelah ini selesai, output tepat sekali menggunakan fflag dari pengaturan awal.

Python 3.8 (pra-rilis) , 45 43 byte

-2 byte terima kasih kepada Erik .

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

Cobalah online!

h%12- jam dalam format 12 jam
h%12*30- sudut jarum jam pada jam penuh
m/2- sudut jarum jam bergerak dalam mhitungan menit
h%12*30+m/2- posisi jarum jam saat ini sebagai sudut
m*6- sudut jarum menit ( 360°/60 = 6°)

Stax , 15 byte

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

Jalankan dan debug itu

• m = jumlah menit sejak tengah malam
• d = 5.5 * m
• Hasilnya adalah min(d % 360, -d % 360).

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

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

Cobalah online!

Arang , 22 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Mengambil input sebagai dua bilangan bulat. Penjelasan:

             Ｎ          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

Cobalah online!

Menggunakan beberapa trik yang dicuri dari jawaban dan perhitungan lain

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)

Cobalah online!

h*30- sudut antara siang dan jam hsaat menitnya 0; jika jam sama atau lebih besar dari 12, sudut ini bisa sama atau lebih besar dari 360 °
m*6- sudut antara siang dan jarum menit
m*.5- sudut jarum jam bergerak maju dari jam penuh setelah mmenit (misalnya: jika jam 4:24, jarum jam bergerak maju 12 derajat dari posisi di jam 4)
h*30-m*5.5- salah satu dari dua sudut antara jarum jam dan jarum menit; koefisien untuk madalah 5.5karena m*6-m*.5=m*5.5; ini masih bukan jawabannya karena dapat berupa nilai yang lebih besar dari 360 ° (misalnya: jika h,m=13,0) atau kurang dari 0 ° (misalnya: jika h,m=12,30)
(h*30-m*5.5)%360- modulo ini memperhitungkan kasus-kasus di mana nilai yang dihitung di atas tidak antara 0 dan 360 °; ini masih bukan jawabannya karena itu bisa menjadi penguat dari dua sudut, sementara kami ingin yang paling sempit
180-abs(180-(h*30-m*5.5)%360)- ini adalah hasil akhir; aturan umum adalah yang x-abs(x-y)setara dengan min(y,x-y), yang akan memberikan hasil yang benar

Tcl , 71 74 59 54 byte

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

Cobalah online!

disimpan 5 byte dengan menggunakan ekspresi lambda

Python 3, 58 57 Bytes

-1 / -2 Terima kasih kepada @Shaggy

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

Implementasi naif, mengambil input dalam bentuk [6,32]. Beberapa byte mungkin dapat dicukur dari baris terakhir khususnya.

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 byte

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

Cobalah online!

Mengambil input sebagai jam diikuti oleh menit pada saluran yang terpisah karena menghemat beberapa byte.

[R], 45 byte

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

Japt , 16 byte

*FÑ aV*5½
mUa360

Cobalah

*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

Cobalah online! (6:32)

Mengambil input sebagai h, m pada stack.

Penjelasan

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

Mengambil jam sebagai input pertama, menit sebagai detik.

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

Pada dasarnya mengimplementasikan rumus berikut:

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))}