Este es un desafío inspirado en la rotación de Chebyshev . Sugiero buscar respuestas allí para inspirarse en este desafío.

Dado un punto en el plano, hay un cuadrado único (un rectángulo con lados iguales) que se centra en el origen e intersecta ese punto ( demostración interactiva ):

Dado un punto p y una distancia d , devuelve el punto obtenido moviendo la distancia d desde p , en sentido antihorario (y en sentido horario para d negativo ), a lo largo del perímetro del cuadrado centrado en el origen que interseca p . Su respuesta debe tener una precisión de al menos 4 dígitos decimales.

Casos de prueba:

(0, 0), 100 -> (0, 0)
(1, 1), 81.42 -> (-0.4200, 1.0000)
(42.234, 234.12), 2303.34 -> (-234.1200, 80.0940)
(-23, -39.234), -234.3 -> (39.2340, -21.8960)

Los siguientes casos de prueba son del desafío original de Martin Ender, y todos son con d = 1 :

(0, 0)       -> (0, 0)
(1, 0)       -> (1, 1)
(1, 1)       -> (0, 1)
(0, 1)       -> (-1, 1)
(-1, 1)      -> (-1, 0)
(-1, 0)      -> (-1, -1)
(-1, -1)     -> (0, -1)
(0, -1)      -> (1, -1)
(1, -1)      -> (1, 0)
(95, -12)    -> (95, -11)
(127, 127)   -> (126, 127)
(-2, 101)    -> (-3, 101)
(-65, 65)    -> (-65, 64)
(-127, 42)   -> (-127, 41)
(-9, -9)     -> (-8, -9)
(126, -127)  -> (127, -127)
(105, -105)  -> (105, -104)

Python 2, 363 335 296 266 262 258 256 233 Bytes

^{Woo, 130 bytes perdidos! ¡Gracias a Neil por guardar 4 bytes, Nathan Merrill por guardar 2 bytes y xnor por guardar unos ridículos 23 bytes!}

La idea general es esta: podemos reducir la distancia recorrida tomando su módulo contra el perímetro del cuadrado. El perímetro se define como 8 veces la mayor de las dos coordenadas, ya que el punto debe descansar sobre él. Luego, después de tomar el módulo, se garantiza que no habrá superposición. También garantiza que solo tengamos que movernos en sentido antihorario, ya que el módulo da un resultado positivo.

A partir de ahí, simplemente uso lo que sabemos de las coordenadas x e y dadas para determinar dónde estamos: arriba, abajo, izquierda, derecha o en una esquina, y determinar la dirección, que puede ser una de 0, 1, 2, 3:

0 --> we are on the 'top', moving 'left'
1 --> we are on the 'left', moving 'down'
2 --> we are on the 'bottom', moving 'right'
3 --> we are on the 'right', moving 'up'

Después de esto, es tan simple como hacer un bucle mientras todavía tenemos que recorrer la distancia, y en función de la dirección que restamos o sumamos a la coordenada apropiada, y le decimos al bucle en qué dirección vamos a seguir.

p,d=input()
x,y=p
s=max(x,y,-x,-y)
d=d%(s*8or 1)
r=[(y<s)*[2,[3,x>-s][x<s]][y>-s],[2*(y<0),3*(y<=0)][x>0]][y*y==x*x]
while s>0<d:f=1-2*(r<2);m=abs(f*s-p[r%2]);j=d>m;p[r%2]=[p[r%2]+f*d,f*s][j];r=-~r%4;d=(d-m)*j
print"%.4f "*2%tuple(p)

Si bien es bastante largo, ciertamente funciona. Aquí hay algunos ejemplos de E / S:

[0, 0], 100 --> 0.0000 0.0000
[1, 1], 81.42 --> -0.4200 1.0000
[42.234, 234.12], 2303.34 --> -234.1200 80.0940
[-23, -39.234], -234.3 --> 39.2340 -21.8960

Pruébelo en línea o ejecute casos de prueba .

JavaScript (ES6), 147 bytes

f=(x,y,d,s=Math.max(x,y,-x,-y),c=(d/8%s+s)%s*8,v=0,w=x+y>0?1:-1,b=(v?x:y)*w+c-s)=>c?b>0?f(v?s*w:x,v?y:s*w,d,s,b,!v,v?w:-w):[x+c*w*v,y+c*w*!v]:[x,y]

Explicación: funciona intentando agregar el vector de dirección mientras se mantiene dentro de los límites del cuadrado. Cualquier sobreimpulso se hace retroceder recursivamente con la dirección girada en sentido antihorario 90 °. La dirección se codifica realmente usando una bandera vertical vy una unidad wpara que los vectores (1, 0), (0, 1), (-1, 0) y (0, -1) se codifiquen con v0, 1, 0 , 1 y wde 1, 1, -1, -1 respectivamente. El vector de dirección puede no apuntar inicialmente en una dirección adecuada, pero nunca apunta hacia atrás, por lo que eventualmente rotará en una dirección utilizable.

f=(x,y,d,                   Input parameters
 s=Math.max(x,y,-x,-y),     Calculate half the side of the square
 c=(d/8%s+s)%s*8,           Reduce the distance modulo the perimeter
 v=0,                       Initial vertical flag
 w=x+y>0?1:-1,              Initial direction
 b=(v?x:y)*w+c-s)=>         Will we overshoot the corner?
  c?b>0?f(v?s*w:x,v?y:s*w,  Advance to the next corner
          d,s,b,!v,v?w:-w): Rotate the direction
        [x+c*w*v,y+c*w*!v]: Advance the remaining amout
    [x,y]                   Nothing to do, zero input