ให้สองจุดAและBหามุมจากบรรทัดหนึ่งAOไปอีกบรรทัดBOเกี่ยวกับจุดOที่Oเป็นต้นกำเนิด ( (0,0)) นอกจากนี้มุมอาจเป็นบวกหรือลบขึ้นอยู่กับตำแหน่งของจุด (ดูตัวอย่าง) การป้อนข้อมูลจะเป็นคะแนนAและBและอาจได้รับในรูปแบบที่สะดวกใด ๆ เอาต์พุตจะเป็นมุมเป็นองศา (แต่จะเป็นบวกถ้าAOหมุนทวนเข็มนาฬิกาเกี่ยวกับจุดกำเนิดเพื่อให้ได้BOและลบถ้าหมุนตามเข็มนาฬิกา) ถ้ามุมเป็น 180 องศาคุณอาจส่งคืนผลลัพธ์เป็นลบหรือบวก ในทำนองเดียวกันมุมอาจเป็นรุ่นบวกหรือลบของมุมเดียวกัน ( 90 degเท่ากับ-270 deg) ตัวอย่าง:

• อินพุต: A(5,5) B(5,-5)เอาต์พุต: -90( AOคือ-90องศาที่หมุนเพื่อรับBO)

• อินพุต: A(5,-5) B(5,5)เอาต์พุต: 90( AOคือ90องศาที่หมุนเพื่อรับBO)

นี่คือรหัส - กอล์ฟดังนั้นรหัสที่สั้นที่สุดในหน่วยไบต์ชนะ!

Pyth, 11 ไบต์

.t-FPM.jMQ6

สาธิต

อินพุตถูกกำหนดในรูปแบบ:

[[Bx, By], [Ax, Ay]]

หากต้องการให้ A มาก่อนสามารถเปลี่ยนได้ 1 ไบต์

คำอธิบาย:

.t-FPM.jMQ6
               Implicit: Q = eval(input())
      .jMQ     Convert input pairs to complex numbers.
    PM         Take their phases (angles in the complex plane).
  -F           Take the difference.
.t        6    Convert to degrees

TI-BASIC ขนาด 13 ไบต์

สำหรับเครื่องคิดเลข TI-83 + / 84 +

Degree
Input Y
min(ΔList(R►Pθ(Ans,∟Y

หากต้องการใช้โปรแกรมนี้ให้ป้อนรายการ{x1,x2}ผ่านตัวแปร Ans และ{y1,y2}ที่พร้อมท์

CJam, 14 ไบต์

q~::ma:-P/180*

นี่เป็นโปรแกรมเต็มรูปแบบที่อ่านอินพุต[[Ax Ay] [Bx By]]จาก STDIN

ลองใช้ออนไลน์ในล่าม CJam

มันทำงานอย่างไร

q~             e# Read and evaluate all input.
  ::ma         e# Replace each point (x, y) with atan2(x, y).
               e# This returns its angle with the positive y axis, measured clockwise.
      :-       e# Compute the difference of the two resulting angles.
               e# This returns the angle between the points, measured counter-clockwise.
        P/180* e# Divide by Pi and multiply by 180 to convert to degrees.

Minkolang 0.9 , 112 ไบต์

ฉันจริงๆต้องการที่จะใช้ฟังก์ชั่นหนุนเป็นตัว -ins ตอนนี้ ... แต่ก็สนุก! (Caveat: สิ่งนี้ให้ผลต่างมุมบวกไม่ใช่ความแตกต่างของมุมที่เซ็นชื่อด้วยข้อ จำกัด ของฉันฉันคิดว่านั่นเป็นเหตุผล)

4[n]0c2c*1c3c*+r4[2;1R]r+1R+0g*12$:;$:8[0ci2*3+d1R;0g$:1i1+[i2*1+d1+$:*]*]$+'3.141592654'25*9;$:$:12$:r-66*5**N.

ลองที่นี่

คำอธิบาย

ฉันจะโพสต์คำอธิบายเพิ่มเติมหากใครต้องการ แต่ส่วนสำคัญของมันคือ:

4[n]                                    Take in 4 integers from input
0c2c*1c3c*+                             dot product
r4[2;1R]r+1R+0g*12$:;                   magnitudes of vectors
$:                                      dot product divided by magnitudes (z)
8[0ci2*3+d1R;0g$:1i1+             *]    Taylor series for arccos
                     [i2*1+d1+$:*]      In particular, the coefficient (1/2 * 3/4 * ...)
$+                                      Add them all up!
'3.141592654'25*9;$:$:                  Divide by pi for converting to degrees
12$:r-                                  Subtract from 1/2 - I now have arccos(z)
66*5**                                  Convert to degrees
N.                                      Output as number and stop.

Mathematica ขนาด 22 ไบต์

{-1,1.}.ArcTan@@@#/°&

ตัวอย่าง:

In[1]:= {-1,1.}.ArcTan@@@#/°&[{{5,5},{5,-5}}]

Out[1]= -90.

In[2]:= {-1,1.}.ArcTan@@@#/°&[{{5,-5},{5,5}}]

Out[2]= 90.

Javascript, 66 ไบต์

let f=(a,b)=>(Math.atan2(b.y,b.x)-Math.atan2(a.y,a.x))*180/Math.PI;

การสาธิต

Julia, 18 25 ไบต์

f(A,B)=angle(B/A)/pi*180

สิ่งนี้อนุมานว่า "รูปแบบใดก็ได้ที่สะดวก" อนุญาตแล้วAและBจะได้รับเป็นตัวเลขที่ซับซ้อน จากนั้นเลขคณิตจำนวนเชิงซ้อนก็เป็นการยกที่หนักทั้งหมด

แก้ไข: ตัวอย่างข้อมูลที่แปลงเป็นฟังก์ชัน เวอร์ชัน 18 ไบต์ใช้งานได้ใน Julia REPL เท่านั้น

Python 2.7, 73 ไบต์

from math import*
f=lambda A,B:degrees(atan2(B[1],B[0])-atan2(A[1],A[0]))

ทดสอบ:

f((5,5),(5,-5)) #-90.0
f((5,-5),(5,5)) #90.0

อ็อกเทฟ 43 ไบต์

f=@(a,b)(cart2pol(b)-cart2pol(a))(1)*180/pi

Input / Output:

octave:40> f([5,5],[5,-5])
ans = -90

octave:41> f([1,0],[0,1])
ans = 90

CJam, 15 ไบต์

l~ma@@ma-P/180*

คิดว่าฉันจะเข้าร่วมในเกม CJam เช่นกัน ลองมันออนไลน์ bx by ax ayการป้อนข้อมูลในรูปแบบของ น่าเสียดายที่นี่เป็นวิธีที่สั้นที่สุดในการท้าทายนี้โดยไม่คัดลอกคำตอบของเดนนิส

TeaScript, 28 ไบต์

ฉันควรใช้ฟังก์ชันตรีโกณฯ จริง ๆ ...

$.atan2(_[3]-y,z-x)*180/$.PI

ลองใส่ออนไลน์ก็ได้a.x a.y b.x b.y

คำอธิบาย

$.atan2(       // Arc Tangent of...
    _[3] - y,  // 4th input - 2nd input
       z - x,  // 3rd input - 1st input
) * 180 / $.PI // Converts rad -> deg

Ruby, 64 , 58 ไบต์

a=->(b){b.map{|c|Math.atan2(*c)}.reduce(:-)*180/Math::PI}

การใช้

a.call [[5, 5], [5, -5]] # => -90.0
a.call [[5, -5], [5, 5]] # => 90.0

JavaScript, 49 ไบต์

(a,b)=>((c=Math.atan2)(...b)-c(...a))/Math.PI*180

อินพุตถูกนำมาในรูปแบบ: [aY, aX], [bY, bX](สังเกตการย้อนกลับ x / y)

Simplex v.0.7 , 13 ไบต์

ฉันดีใจที่ฉันเพิ่มmathrelations: D น่าเสียดายที่ฉันไม่สามารถรับอินพุตแบบจุด ดังนั้นฉันใส่แต่ละจุดเป็นตัวเลขแยกต่างหาก (Axe, Ay, Bx, By) (ฉันใช้สิ่งนี้เป็นทรัพยากร)

(iRi~^fR)2LSo
(       )2    ~~ repeat inner twice
 iRi          ~~ take two chars of input (x,y)
    ~         ~~ switch top 2 on stack
     ^f       ~~ apply atan2 on (y,x)
       R      ~~ go right
          L   ~~ go left
           S  ~~ subtract result
            o ~~ output as number

ฉันสามารถบันทึกตัวอักษรถ้าฉันสามารถรับอินพุตเป็น (Ay, Axe, By, Bx):

(iRi^fR)2LSo

C, 88 ไบต์

#include<math.h>
typedef double d;d g(d x,d y,d a,d b){return atan2(b-y,a-x)*180/M_PI;}

ต้องรวบรวมกับ GCC จะใช้ประโยชน์จากM_PIการถูกกำหนดไว้ในmath.hฐานะเป็นส่วนหนึ่งของGCC ในตัวของค่าคงที่ทางคณิตศาสตร์ ลองใช้ออนไลน์ - เนื่องจาก ideone ไม่ได้ใช้ GCC (เห็นได้ชัด) จำเป็นต้องมีไบต์เพิ่มอีกสองสามตัวเพื่อให้ตัวเลข enough เพียงพอที่จะแม่นยำ