Một đồng hồ analog có 2 tay *: Giờ và phút.
Những bàn tay này khoanh tròn mặt đồng hồ khi thời gian trôi qua. Mỗi vòng quay đầy đủ của kim phút sẽ tạo ra 1/12 vòng quay của kim giờ. 2 vòng quay đầy đủ của kim giờ biểu thị một ngày đầy đủ.

Vì các tay này được cố định vào cùng một điểm trung tâm và xoay quanh điểm đó, bạn luôn có thể tính góc giữa các tay. Trong thực tế có 2 góc tại bất kỳ thời điểm nào; Một cái lớn hơn và một cái nhỏ hơn (đôi khi cả hai sẽ bằng 180, nhưng điều đó không quan trọng)

* Đồng hồ giả định của chúng tôi không có kim giây

Bài tập

Cho thời gian ở định dạng 24 giờ, xuất ra góc nhỏ hơn giữa hai bàn tay, tính bằng độ. Nếu hai bàn tay đối diện trực tiếp với nhau (chẳng hạn như tại 6:00, 18:00v.v.), hãy xuất 180

Quy tắc

Đầu vào có thể được lấy là: - Một chuỗi phân tách bằng dấu phân cách : 6:32, 14.26 - 2 giá trị, chuỗi hoặc int riêng biệt : 6, 32, 14, 26 - Một mảng gồm 2 giá trị, chuỗi hoặc ints : [6, 32],[14, 26]

Bạn cũng có thể tùy chọn xác định rằng câu trả lời của bạn yêu cầu đầu vào có đệm đến 2 chữ số (giả sử bạn lấy dây), ví dụ: 06:32, 06, 32,[06, 32]

Bạn cũng có thể tùy chọn đảo ngược thứ tự của các yếu tố đầu, lấy phút sau đó giờ, ví dụ: 32:6, 32, 6,[26, 14]

Giờ sẽ là một giá trị số nguyên giữa 0và 23(bao gồm) Phút sẽ là một giá trị số nguyên giữa 0và 59(bao gồm)

Bạn có thể giả sử rằng kim phút bắt đầu tăng 6 độ dọc theo mặt (một vị trí cách đều nhau cho mỗi giá trị phút)
Bạn có thể giả sử rằng kim giờ chạm vào mức tăng 0,5 độ dọc theo mặt (một vị trí cách đều nhau cho mỗi giá trị phút trên giá trị giờ)

Đầu ra phải được đưa ra theo độ, không phải radian. Bạn có thể bao gồm một dấu .0cho toàn bộ số

Chấm điểm

Đây là môn đánh gôn để có ít byte nhất trong mỗi ngôn ngữ !

Tủ thử

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

Có đầu vào như (h)(m).

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

Hãy thử trực tuyến!

Làm sao?

Thay vì làm việc trực tiếp trong phạm vi $[0..360]$ , chúng tôi xác định một biến tạm thời $x$ trong phạm vi $[0..4]$ :

Các góc tính theo độ được cho bởi:

Tuy nhiên, công thức được triển khai một chút khác biệt trong mã JS, vì chúng tôi chắc chắn muốn tránh sử dụng độ dài Math.abs()và Math.min().

Thay vì tính giá trị tuyệt đối, chúng tôi buộc một giá trị dương trong $[0..12]$ bằng cách tính toán:

Và thay vì tính toán mức tối thiểu, chúng tôi xác định trong trường hợp nào chúng tôi chỉ bằng cách thực hiện một bit VÀ với $2$ - và đây là lý do tại sao chúng tôi chọn một khoảng giới hạn bởi lũy thừa $2$ ở vị trí đầu tiên.

Thạch , 14 12 byte

ד<¿‘Iæ%Ø°AH

Hãy thử trực tuyến!

Một liên kết đơn thể lấy thời gian làm danh sách hai số nguyên: giờ, phút.

Cảm ơn @JonathanAllan vì đã tiết kiệm 2 byte!

Giải trình

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

Chấp nhận hai đầu vào của giờ sau đó là phút. Sử dụng phương pháp tương tự như câu trả lời này

Dùng thử tại MATL Online

Giải trình

      % 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

Ngôn ngữ Wolfram (Mathicala) , 30 29 28 byte

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

Hãy thử trực tuyến!

phiên bản không có bản quyền:

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

Đối số của hàm # = {h,m}chứa giờ và phút. Danh sách hai chiều dài này được hiểu là một vectơ và sản phẩm chấm với {30,-5.5}được tính : #.{30,-5.5} = 30*h-5.5*m. Sau đó, chúng tôi tính toán mô đun đối xứng 360 với Mod[#.{30,-5.5}, 360, -180]việc đưa ra một góc trong khoảng -180 .. + 180. Abslấy giá trị tuyệt đối của chúng.

Vì tất cả các toán tử liên quan là tuyến tính, chúng ta có thể nhân và chia tất cả các số xuất hiện tuy nhiên chúng thuận tiện nhất. Bằng cách kéo một yếu tố5 ra khỏi biểu thức và chia tất cả các số trong biểu thức cho 5, số byte được giảm thiểu.

Nhà giả kim , 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

Hãy thử trực tuyến!

Giải trình

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

Thiết lập ban đầu. Nhập giờ và phút vào hvà m, đặt góc hiện tại dthành 360 độ (720 nửa độ), thiết lập ađể tính góc chính và đặt cờ đầu ra.

h->60d
m+11d->

Mỗi giờ thêm 30 độ, và mỗi phút trừ 5,5 độ.

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

Trong khi rcờ (đảo ngược) không được đặt, mỗi dnguyên tử nên di chuyển một anguyên tử sang b. Điều này xảy ra sau khi tất cả các phút được sử dụng hết, để tránh một "điều kiện cuộc đua". Khi không acòn nguyên tử nào , đặt rđể đảo ngược dòng chảy này.

Lưu ý rằng quy tắc thứ hai này có thể kích hoạt nhiều lần và thậm chí có thể kích hoạt trước quy tắc thiết lập ban đầu. Điều này không gây hại gì cả, vì vậy không cần phải ngăn chặn điều này. Điều 0xkiện xử lý trường hợp cạnh: khi đầu vào là 6:00, không có anguyên tử nào khi chương trình kết thúc, nhưng có xcác nguyên tử nếu kết quả cuối cùng ít nhất là 1 độ.

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

Ngược lại: khi góc đã ký lớn hơn 180 độ, di chuyển bcác nguyên tử ađể giảm góc tới đầu ra. Dừng đảo ngược khi góc đạt "360".

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

Khi tất cả các nguyên tử độ được sử dụng hết, chia cho 2 để có được góc tới.

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

Sau khi hoàn thành, xuất chính xác một lần bằng cách sử dụng fcờ từ thiết lập ban đầu.

Python 3.8 (tiền phát hành) , 45 43 byte

-2 byte nhờ Erik .

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

Hãy thử trực tuyến!

h%12- giờ ở định dạng 12 giờ
h%12*30- góc của kim giờ trong toàn bộ giờ
m/2- góc của kim giờ di chuyển theo mphút
h%12*30+m/2- vị trí hiện tại của kim giờ như một góc
m*6- góc của kim phút ( 360°/60 = 6°)

Stax , 15 byte

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

Chạy và gỡ lỗi nó

• m = số phút kể từ nửa đêm
• d = 5.5 * m
• Kết quả là min(d % 360, -d % 360).

C # (Trình biên dịch tương tác Visual C #) , 47 45 byte

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

Hãy thử trực tuyến!

Than , 22 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Lấy đầu vào là hai số nguyên. Giải trình:

             Ｎ          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

Hãy thử trực tuyến!

Sử dụng một vài thủ thuật bị đánh cắp từ các câu trả lời và tính toán khác

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)

Hãy thử trực tuyến!

h*30- góc giữa trưa và giờ hkhi phút là 0; nếu giờ bằng hoặc lớn hơn 12, góc này có thể bằng hoặc lớn hơn 360 °
m*6- góc giữa trưa và kim phút
m*.5 - góc giờ di chuyển về phía trước từ toàn bộ giờ sau mphút (ví dụ: nếu là 4:24, kim giờ di chuyển về phía trước 12 độ so với vị trí của nó lúc 4 giờ)
h*30-m*5.5- một trong hai góc giữa kim giờ và kim phút; hệ số chom là 5.5vì m*6-m*.5=m*5.5; đây vẫn chưa phải là câu trả lời vì nó có thể là giá trị lớn hơn 360 ° (ví dụ: if h,m=13,0) hoặc nhỏ hơn 0 ° (ví dụ: ifh,m=12,30 )
(h*30-m*5.5)%360- modulo này tính đến các trường hợp trong đó giá trị tính toán ở trên không nằm trong khoảng từ 0 đến 360 °; đây vẫn chưa phải là câu trả lời vì nó có thể là bộ khuếch đại của hai góc, trong khi chúng tôi muốn hẹp nhất
180-abs(180-(h*30-m*5.5)%360)- đây là kết quả cuối cùng; quy tắc chung x-abs(x-y)là tương đương vớimin(y,x-y), sẽ cho kết quả chính xác

Tcl , 71 74 59 54 byte

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

Hãy thử trực tuyến!

đã lưu 5 byte bằng cách sử dụng biểu thức lambda

Trăn 3, 58 57 byte

-1 / -2 Cảm ơn @Shaggy

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

Thực hiện ngây thơ, lấy đầu vào dưới dạng [6,32] . Một số byte có thể được cạo ra khỏi dòng cuối cùng đặc biệt.

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

Hãy thử trực tuyến!

Mất đầu vào là hàng giờ sau vài phút trên một dòng riêng biệt vì nó đã lưu một vài byte.

[R], 45 byte

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

Japt , 16 byte

*FÑ aV*5½
mUa360

Thử nó

*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

Hãy thử trực tuyến! (6:32)

Lấy đầu vào là h, m trên ngăn xếp.

Giải trình

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

Mất hàng giờ như đầu vào đầu tiên, phút là thứ hai.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

Về cơ bản thực hiện các công thức sau:

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