Diberi dua titik Adan B, cari sudut dari garis AOke garis BOtentang titik di Omana titik Oasal ( (0,0)). Selain itu, sudut mungkin positif atau negatif tergantung pada posisi titik (lihat contoh). Masukan akan berupa poin Adan B, dan dapat diberikan dalam bentuk apa pun yang mudah. Output akan menjadi sudut dalam derajat (tetapi positif jika AOdiputar berlawanan arah jarum jam tentang asal untuk mendapatkan BOdan negatif jika diputar searah jarum jam). Jika sudutnya 180 derajat Anda dapat mengembalikan output negatif atau positif. Demikian pula, sudut dapat menjadi versi positif atau negatif dari sudut yang sama ( 90 degsama dengan -270 deg). Contoh:

• Input: A(5,5) B(5,-5)Output: -90( AOdiputar -90derajat untuk mendapatkan BO).

• Input: A(5,-5) B(5,5)Output: 90( AOdiputar 90derajat untuk mendapatkan BO).

Ini adalah kode-golf , jadi kode terpendek dalam byte menang!

Pyth, 11 byte

.t-FPM.jMQ6

Demonstrasi

Masukan diberikan dalam format:

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

Jika diinginkan bahwa A lebih dulu, ini dapat diubah untuk 1 byte.

Penjelasan:

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

Untuk kalkulator TI-83 + / 84 + series.

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

Untuk menggunakan program ini, masukkan daftar {x1,x2}melalui variabel Ans, dan {y1,y2}saat diminta.

CJam, 14 byte

q~::ma:-P/180*

Ini adalah program lengkap yang membaca input sebagai [[Ax Ay] [Bx By]] dari STDIN.

Cobalah online di penerjemah CJam .

Bagaimana itu bekerja

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 byte

Saya benar - benar ingin menerapkan fungsi trigonometri sebagai bawaan sekarang ... tapi ini menyenangkan! (Peringatan: ini menghasilkan perbedaan sudut positif, bukan perbedaan sudut yang ditandatangani. Mengingat keterbatasan saya, saya pikir itu dibenarkan.)

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.

Coba di sini.

Penjelasan

Saya akan memposting penjelasan yang lebih lengkap jika ada yang menginginkannya, tetapi intinya adalah:

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 byte

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

Contoh:

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 byte

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

demo

Julia, 18 25 byte

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

Ini mengasumsikan bahwa "segala bentuk yang mudah" sudah memungkinkan Adan Bdiberikan sebagai bilangan kompleks. Kemudian, bilangan aritmatika kompleks melakukan semua pengangkatan berat.

Sunting: cuplikan yang dikonversi berfungsi. Versi 18 byte hanya berfungsi di REPL Julia.

Python 2.7, 73 Bytes

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

Uji:

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

Oktaf, 43 byte

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 byte

l~ma@@ma-P/180*

Kupikir aku akan masuk ke game CJam juga. Cobalah online . Input dalam bentuk bx by ax ay. Sayangnya, ini adalah metode terpendek untuk melakukan tantangan ini tanpa menyalin jawaban Dennis.

TeaScript, 28 byte

Saya benar-benar harus menerapkan fungsi trig ...

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

Coba input online inia.x a.y b.x b.y

Penjelasan

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

Ruby, 64 , 58 byte

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

Pemakaian

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

JavaScript, 49 byte

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

Input diambil dalam bentuk: [aY, aX], [bY, bX](perhatikan pembalikan x / y)

Simplex v.0.7 , 13 byte

Saya senang saya menambahkan mathrelations: D Sayangnya, saya tidak dapat mengambil input yang tepat. Jadi, saya memasukkan setiap titik sebagai angka yang terpisah (Ax, Ay, Bx, By). (Saya menggunakan ini sebagai sumber daya.)

(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

Saya dapat menyimpan char jika saya dapat mengambil input sebagai (Ay, Ax, By, Bx):

(iRi^fR)2LSo

C, 88 byte

#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;}

Membutuhkan kompilasi dengan GCC untuk mengambil keuntungan dari M_PIdidefinisikan math.hsebagai bagian dari konstanta matematika bawaan GCC . Cobalah online - karena ideone tidak menggunakan GCC (tampaknya), beberapa byte tambahan diperlukan untuk enough angka yang cukup agar akurat.