Dati due punti Ae B, trova l'angolo da una riga AOall'altra BOrispetto al punto in Ocui Oè l'origine ( (0,0)). Inoltre, l'angolo può essere positivo o negativo a seconda della posizione dei punti (vedere esempi). Gli input saranno punti Ae B, e possono essere dati in qualsiasi forma conveniente. L'output sarà l'angolo in gradi (ma è positivo se AOviene ruotato in senso antiorario rispetto all'origine per ottenere BOe negativo se viene ruotato in senso orario). Se l'angolo è di 180 gradi, è possibile che venga restituito un output negativo o positivo. Allo stesso modo, l'angolo può essere la versione positiva o negativa dello stesso angolo ( 90 degè uguale a -270 deg). Esempi:

• Input: A(5,5) B(5,-5)Output: -90( gradi AOruotati -90per ottenere BO).

• Input: A(5,-5) B(5,5)Output: 90( gradi AOruotati 90per ottenere BO).

Questo è code-golf , quindi vince il codice più breve in byte!

Pyth, 11 byte

.t-FPM.jMQ6

Dimostrazione

L'input è dato nel formato:

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

Se si desidera che A venga prima, questo può essere modificato per 1 byte.

Spiegazione:

.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

Per calcolatori serie TI-83 + / 84 +.

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

Per utilizzare questo programma, immettere l'elenco {x1,x2}tramite la variabile Ans e {y1,y2}al prompt.

CJam, 14 byte

q~::ma:-P/180*

Questo è un programma completo che legge l'input come [[Ax Ay] [Bx By]]da STDIN.

Provalo online nell'interprete CJam .

Come funziona

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

Voglio davvero implementare le funzioni di trigthon come built-in ora ... ma è stato divertente! (Avvertenza: questo produce la differenza di angolo positivo, non la differenza di angolo con segno. Dati i miei limiti, penso che sia giustificato.)

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.

Provalo qui.

Spiegazione

Pubblicherò una spiegazione più completa se qualcuno lo desidera, ma l'essenza è:

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@@@#/°&

Esempio:

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;

dimostrazione

Julia, 18 25 byte

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

Ciò presuppone che "qualsiasi forma conveniente" consenta già Ae Bsia data come numeri complessi. Quindi, l' aritmetica dei numeri complessi fa tutto il sollevamento pesante.

Modifica: snippet convertito in funzione. La versione a 18 byte funziona solo nel Julia REPL.

Python 2.7, 73 byte

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

Test:

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

Ottava, 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*

Pensavo di entrare anche nel gioco CJam. Provalo online . L'input è in forma di bx by ax ay. Sfortunatamente, questo è il metodo più breve per affrontare questa sfida senza copiare la risposta di Dennis.

TeaScript, 28 byte

Dovrei davvero implementare funzioni trig ...

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

Provalo è l' input onlinea.x a.y b.x b.y

Spiegazione

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

Rubino, 64 , 58 byte

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

uso

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

L'immissione è in forma: [aY, aX], [bY, bX](notare l'inversione x / y)

Simplex v.0.7 , 13 byte

Sono contento di aver aggiunto mathrelations: D Sfortunatamente, non posso accettare input puntuali. Quindi, inserisco ogni punto come un numero separato (Ax, Ay, Bx, By). (Io ho usato questo come una risorsa.)

(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

Posso salvare un carattere se posso prendere input come (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;}

Richiede la compilazione con GCC per trarre vantaggio M_PIdall'essere definito math.hcome parte delle costanti matematiche incorporate di GCC . Provalo online - dal momento che ideone non usa GCC (apparentemente), sono necessari alcuni byte aggiuntivi affinché cifre sufficienti di π siano accurate.