Dados dos puntos Ay B, encuentre el ángulo de línea AOa línea BOsobre el punto Odonde Oestá el origen ( (0,0)). Además, el ángulo puede ser positivo o negativo dependiendo de las posiciones de los puntos (ver ejemplos). La entrada será puntos Ay B, y se puede dar en cualquier forma conveniente. La salida será el ángulo en grados (pero es positivo si AOse gira en sentido antihorario sobre el origen a obtener BOy negativo si se gira en sentido horario). Si el ángulo es de 180 grados, puede devolver una salida negativa o positiva. Del mismo modo, el ángulo puede ser la versión positiva o negativa del mismo ángulo ( 90 deges igual a -270 deg). Ejemplos:

• Entrada: A(5,5) B(5,-5)Salida: -90( AOse rota -90grados para obtener BO).

• Entrada: A(5,-5) B(5,5)Salida: 90( AOse rota 90grados para obtener BO).

Este es el código de golf , por lo que gana el código más corto en bytes.

Pyth, 11 bytes

.t-FPM.jMQ6

Demostración

La entrada se da en el formato:

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

Si se desea que A venga primero, esto se puede cambiar por 1 byte.

Explicación:

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

Para calculadoras de la serie TI-83 + / 84 +.

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

Para usar este programa, ingrese a la lista a {x1,x2}través de la variable Ans y {y1,y2}en el indicador.

CJam, 14 bytes

q~::ma:-P/180*

Este es un programa completo que lee la entrada [[Ax Ay] [Bx By]]desde STDIN.

Pruébelo en línea en el intérprete de CJam .

Cómo funciona

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 bytes

Yo realmente quiero para implementar funciones trigonométricas como muebles empotrados ahora ... pero esto era divertido! (Advertencia: esto genera la diferencia de ángulo positiva, no la diferencia de ángulo con signo. Dadas mis limitaciones, creo que eso está justificado).

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.

Pruébalo aquí.

Explicación

Publicaré una explicación más completa si alguien lo quiere, pero lo esencial es:

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 bytes

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

Ejemplo:

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 bytes

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

manifestación

Julia, 18 25 bytes

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

Esto supone que "cualquier forma conveniente" ya permite Ay Bse dará como números complejos. Entonces, la aritmética de números complejos hace todo el trabajo pesado.

Editar: fragmento convertido para funcionar. La versión de 18 bytes solo funciona en Julia REPL.

Python 2.7, 73 bytes

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

Prueba:

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

Octava, 43 bytes

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

De entrada y salida:

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

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

CJam, 15 bytes

l~ma@@ma-P/180*

Pensé que también entraría en el juego de CJam. Pruébalo en línea . La entrada está en forma de bx by ax ay. Desafortunadamente, este es el método más corto para hacer este desafío sin copiar la respuesta de Dennis.

TeaScript, 28 bytes

Realmente debería de implementar funciones trigonométricas ...

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

Pruébalo en línea entrada esa.x a.y b.x b.y

Explicación

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

Ruby, 64 , 58 bytes.

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 bytes

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

La entrada se toma en forma: [aY, aX], [bY, bX](observe el x / y invertido)

Simplex v.0.7 , 13 bytes

Me alegro de haber agregado mathrelations: D Desafortunadamente, no puedo tomar información puntual. Entonces, ingreso cada punto como un número separado (Ax, Ay, Bx, By). (Usé esto como un recurso).

(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

Puedo guardar un carácter si puedo tomar datos como (Ay, Axe, By, Bx):

(iRi^fR)2LSo

C, 88 bytes

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

Requiere compilar con GCC para aprovechar M_PIsu definición math.hcomo parte de las constantes matemáticas integradas de GCC . Pruébelo en línea : dado que ideone no usa GCC (aparentemente), se necesitan unos pocos bytes adicionales para que los dígitos suficientes de π sean precisos.