¡Bienvenido a mi primer desafío de código de golf! :) Vamos directo a ello.

Desafío:

Dados dos vectores de coma flotante, O (origen) y T (objetivo), debe crear un programa para imprimir los valores L y R en STDOUT.

1. O es una esquina de la plaza
2. T es una esquina del cuadrado que se encuentra enfrente de O
3. L es el punto 2D (esquina) que marca el otro punto del cuadrado incompleto
4. R es el punto 2D (esquina) opuesto a L

Reglas

5. Los valores para O y T deben leerse desde STDIN (ver entradas de ejemplo).
6. Nuevamente, los valores de L y R deben imprimirse en STDOUT.

Puntuación y bonificaciones

7. Cuenta los bytes de tu programa.
8. Si su programa dibuja líneas que se conectan entre O a L y T a R , reste 15 bytes del recuento de bytes.

Ejemplos

La primera línea cubre entradas (primeros corchetes para O y siguientes corchetes para T ) y otra línea representa la salida esperada.

• [0, 0] [3, 3] Esperado: [0, 3] [3, 0]
• [0, 0] [-2, -2] Esperado: [-2, 0] [0, -2]
• [1, -1] [4, 2] Esperado: [1, 2] [4, -1]
• [0, -1] [0, 1] Esperado: [-1, 0] [1, 0]

AVISO : ¡las entradas y salidas pueden ser puntos flotantes!

¡Información importante!

• Los valores O y T pueden tomarse en cualquier formato, siempre que provengan de STDIN (ej. Dentro [] o () ...), use el formato que desee.
• L y R se pueden imprimir en cualquier orden.
• Recuerde: cuando (O-> L-> T-> R-> O) están conectados, ¡cada lado debe tener la misma longitud!

Victorioso

• ¡Este es el código de golf, por lo que gana la menor cantidad de bytes!
• La respuesta del ganador se aceptará el domingo 15.11.2015 20: 00-22: 00 (hora de Finlandia) (si no me equivoco, esa fecha está escrita como 11.15.2015 en los Estados Unidos, no se confunda).

¡Feliz golf!

En serio , 11 bytes

Un puerto de mi respuesta TI-BASIC. Calcula mean(X)+i*(X-mean(X)).

,;Σ½;)±+ï*+

Explicación:

,           Read input
;           Duplicate
Σ½          Half the sum (the mean) of the top copy
;           Copy the mean
)           Rotate stack to the left
            Now there's a copy of the mean on the bottom
±+          Negate mean and add to input list
ï*          Multiply by i
+           Add to mean

Entrada como una lista de dos números complejos: [1-1j,4+2j]y salida en el mismo formato: [(4-1j), (1+2j)].

En serio , 25 bytes

,i││-++½)+-+½)++-½)±+++½)

Toma la entrada como una lista: [x1,y1,x2,y2]

La misma estrategia que mi respuesta de Python, ¡pero en serio!

Explicación:

,      get input
i      flatten list
││     duplicate stack twice, so that we have 4 copies of the input total
-++½)  calculate the first x-value using the formula (x1-y1+x2+y2)/2, and shove it to the end of the stack
+-+½)  calculate the first y-value using (x1+y1-x2+y2)/2, and shove it to the end of the stack
++-½)  calculate the second x-value using (x1+y2+x2-y2)/2, and shove it to the end of the stack
±+++½) calculate the second y-value using (-x1+y1+x2+y2)/2, and shove it to the end of the stack

Pruébalo en línea

TI-BASIC, 16 bytes

Para una calculadora de la serie TI-83 + u 84+.

Input X
i∟X+.5sum(∟X-i∟X

A menos que haya entendido mal, OP dijo que estaban bien con tomar entradas y salidas como números complejos. losi aquí es la unidad imaginaria, no la variable estadística.

TI-BASIC tiene una mean(función, pero molestamente no funciona con listas complejas, arrojando un ERR:DATA TYPE.

Ingrese el formulario {1-i,4+2i}para [[1,-1],[4,2]]. La salida está en la forma {4-i 1+2i}para [[1,2][4,-1]].

Matlab, 51 45 46 45 42 bytes

Ahora se espera la entrada en un vector de columna: [x0;y0;x1;y1](salida en el mismo formato) Acabo de modificarlo para que sea un programa completo.

z=eye(4);disp((.5-z([2:4,1],:))*input(''))

O alternativamente

z=[1,1;-1,1];disp([z',z;z,z']*input('')/2)

Vieja solución:

La entrada espera vectores de columna, p. Ej. f([0;0],[3;3])

@(a,b)[0,1;-1,0]*(b-a)*[.5,-.5]+(b+a)*[.5,.5]

También devuelve dos vectores de columna (como una matriz de 2x2).

Japt, 29 28 bytes

Japt es una versión abreviada de Ja vaScri pt . Interprete

1o5 mZ=>$eval$(Uq'+)/2-UgZ%4

Tenga en cuenta que las funciones de flecha requieren un navegador compatible con ES6, como las versiones más recientes de Firefox. La entrada entra como una matriz de 4 elementos, por ejemplo [1,-1,4,2].

Cómo funciona

         // Implicit: U = input array
1o5      // Create a range of integers from 1 to 5. Returns [1,2,3,4]
mZ=>     // Map each item Z in this range to:
$eval$(  //  evaluate:
 Uq'+    //   U joined with "+" (equivalent to summing U)
)/2      //  divided by 2,
-UgZ%4   //  minus the item at Z%4 in the input. This translates to [y₁,x₂,y₂,x₁],
         //  which in turn tranlsates to:
         //   [(x₁-y₁+x₂+y₂)/2, (x₁+y₁-x₂+y₂)/2, (x₁+y₁+x₂-y₂)/2, (-x₁+y₁+x₂+y₂)/2]
         //  which is [Lx,Ly,Rx,Ry], or [Rx,Ry,Lx,Ly], depending on the situation.
         // Implicit: Output last expression

Cómo fue golfizado

Primero intenté simplemente copiar el enfoque Python de @ Mego. Esto me dejó con este monstruo de 48 bytes:
(Nota: la entrada no debe estar envuelta actualmente en una matriz).

[U-V+W+X /2,(U+V-W+X /2,(U+V+W-X /2,(V+W+X-U /2]

Dado que cada uno de estos elementos debe dividirse entre 2, es más corto asignar toda la matriz con mY=>Y/2:

[U-V+W+X,U+V-W+X,U+V+W-X,V+W+X-U]mY=>Y/2

¿Ahora que? Bueno, la matriz ahora simplemente agrega tres de las entradas y resta la cuarta, siguiendo el patrón 1,2,3,0. Entonces, podríamos empacar las entradas en una matriz, luego sumarlas, dividirlas por 2 y restar el elemento necesario:

[1,2,3,0]mZ=>(Ug0 +Ug1 +Ug2 +Ug3)/2-UgZ

¡Bien guardado un byte! Pero, ¿es posible reducir la matriz al principio? Intentemos empaquetarlo en una cadena, luego dividirlo en una matriz con a:

"1230"a mZ=>(Ug0 +Ug1 +Ug2 +Ug3)/2-UgZ

Mira eso, otro byte guardado. ¿Pero hay una manera aún mejor? Bueno, podemos usar el hecho de que [1,2,3,0] ≡ [1,2,3,4] mod 4:

1o5 mZ=>(Ug0 +Ug1 +Ug2 +Ug3)/2-UgZ%4

¡Otros dos bytes! Ahora vamos a alguna parte. Pero eso Ug0 +Ug1 +Ug2 +Ug3está acaparando mucho espacio. ¿Qué pasa si reducimos la matriz con la suma?

1o5 mZ=>Ur(X,Y =>X+Y /2-UgZ%4

Wow, eso realmente ayudó! Ahora tenemos 29 bytes. Y gracias a @ ן nɟuɐɯɹɐ ן oɯ, incluso pude jugar golf a otro byte de la reducción. Pero si pudiéramos usar un incorporado para sumar la matriz, sería mucho más corto:

1o5 mZ=>Uu /2-UgZ%4

19 bytes! ¡Increíble! Desafortunadamente, Japt aún no tiene tales incorporaciones. Agregaré esto cuando tenga la oportunidad. ¡Las sugerencias son bienvenidas, ya sea para el programa o el idioma!

Bueno, a partir de la v1.4.4, he implementado muchas más funciones en Japt de lo que había planeado originalmente. Comenzando con el plan original para la versión más corta:

1o5 mZ=>Uu /2-UgZ%4

Primero necesitamos cambiar algunas cosas: las funciones se definen con {, y la función de suma es x. Esta versión funciona como está:

1o5 mZ{Ux /2-UgZ%4

Ahora, @es una forma abreviada de XYZ{, que nos permite guardar un byte cambiando de Za X. Además, £es un atajo para m@guardar otro byte:

1o5 £Ux /2-UgX%4

Recientemente implementé una función Uen la que al principio del programa generalmente se puede omitir. Sin embargo, debido a un error de implementación, esto también funciona con funciones:

1o5 £x /2-UgX%4

Finalmente, la gfunción ahora se ajusta si el índice ha pasado el final de la cadena, lo que nos permite eliminar el %4total de 13 bytes :

1o5 £x /2-UgX

Y pensé que 19 era increíble ;-) ¡ Pruébelo en línea!

Javascript (Node.js / ES6), 154 bytes

process.stdin.on('data',s=>(s=s.toString().split(','),a=s[0]-0,b=s[1]-0,x=s[2]-0,y=s[3]-0,console.log([a+(c=(a+x)/2-a)+(d=(b+y)/2-b),b+d-c,a+c-d,b+d+c])))

Obtener stdin es la parte más larga del código. La entrada debe ser los puntos separados por comas:

echo "0,0,3,3" | node square.js

ngn APL, 21 bytes

⎕←F.5 0J.5×(F←+/,-/)⎕

Esto toma la entrada como un par de números complejos (por ejemplo, 1J¯1 4J2) e imprime la salida de la misma manera (por ejemplo, 4J¯1 1J2). Pruébelo en línea en la demostración ngn / apl .

Pyth, 12 bytes

.jL.OQ-R.OQQ

Esto toma la entrada como un par de números complejos (por ejemplo, 1-1j, 4+2j) e imprime la salida como una matriz (por ejemplo, [(4-1j), (1+2j)]). Pruébalo en línea.

𝔼𝕊𝕄𝕚𝕟, 29 caracteres / 43 bytes

ô(ѨŃ(1,5)ć⇀ë(ïø`+`⸩/2-ï[$%4]⸩

Try it here (Firefox only).

CJam, 30 bytes

q~_:.+\:.-(W*+_2$.+@@.-].5ff*`

Pruébalo en línea

Esto toma la entrada como una lista de listas, por ejemplo, para el último ejemplo:

[[0 -1] [0 1]]

Explicación:

q~      Get and interpret input.
_       Make a copy.
:.+     Reduce the list of two points with vector sum operator.
\       Swap copy of input to top.
:.-     Reduce the list of two points with vector difference operator.
(W*+    Turn (x, y) into orthogonal (y, -x) by popping off first element, inverting
        its sign, and concatenating again. We now have center and offset vector.
_2$     Create a copy of both...
.+      ... and add them.
@@      Rotate original values to top...
.-      ... and subtract them.
]       Wrap the two results...
.5ff*   ... and multiply all values by 0.5.
`       Convert list to string.

Prólogo, 118 bytes

p([A,B],[C,D]):-read([E,F,G,H]),I is(E+G)/2,J is(F+H)/2,K is(G-E)/2,L is(H-F)/2,A is I-L,B is J+K, C is I+L, D is J-K.

Ligeramente más legible:

p([A,B],[C,D]):-read([E,F,G,H]),
                        I is(E+G)/2,
                        J is(F+H)/2,
                        K is(G-E)/2,
                        L is(H-F)/2,
                        A is I-L,
                        B is J+K, 
                        C is I+L, 
                        D is J-K.

Para iniciar el programa:

p(X,Y).

Ejemplo de entrada cuando las esquinas conocidas son [1, -1] [4, 2]:
[1, -1,4,2]

Ejemplo de salida, donde X e Y contendrán las esquinas desconocidas:
X = [1.0, 2.0],
Y = [4.0, -1.0]

Pruébelo en línea aquí

Editar: modificado para leer la entrada de STDIN

Python 3, 102 bytes

g=lambda a,b,c,d:((a-b+c+d)/2,(a+b-c+d)/2,(a+b+c-d)/2,(d+b-a+c)/2)
print(g(*map(float,input().split())))

La entrada se toma en forma x1 y1 x2 y2, en una sola línea.

Pruébalo en línea

Python 2, 56 bytes

i=input()
s=sum(i)/2.0
print s-i[1],s-i[2],s-i[3],s-i[0]

La entrada puede ser x1,y1,x2,y2o(x1,y1,x2,y2)