Pinpointing lateral cuadrado

13

¡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

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

Puntuación y bonificaciones

  1. Cuenta los bytes de tu programa.
  2. 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!

Yytsi
fuente
3
En caso de que no lo sepa, permítame recomendarle el entorno limitado para futuros desafíos, donde puede obtener comentarios y pulir su desafío antes de que se publique (y antes de que los cambios puedan invalidar las respuestas existentes).
Martin Ender
¿Podemos tomar la entrada como una lista de dos números complejos?
lirtosiast
@ThomasKwa seguro que puedes tomarlo como una lista. ¿No es una entrada un número complejo cuando se da ...? Quiero decir que no tienes que conocer personalmente el valor de la computadora para calcularlo, ¿verdad?
Yytsi
Cuando dices "punto del cuadrado", ¿parece que te refieres a una esquina? Hay muchos otros puntos en un cuadrado.
Reto Koradi
@RetoKoradi Tienes razón. Me refiero a una esquina con eso.
Yytsi

Respuestas:

8

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)].

lirtosiast
fuente
3
Estoy muy orgulloso ...
Mego
Después de que se publicó esta respuesta, Mego agregó la æmedia de la lista y causó que î(multiplicar por i) se vectorizara, lo que permitió una solución de 9 bytes no competitiva. En serio está empezando a convertirse en un lenguaje realmente bueno.
lirtosiast
Un buen lenguaje "en serio". @ThomasKwa
Addison Crump
¿No son Σ2 bytes?
Ash Burlaczenko
@AshBurlaczenko Parece que en serio usa la codificación CP437 , donde Σtiene el punto de código 0xF4.
Dennis
6

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

Mego
fuente
3
¡Esto es realmente genial! (Juego de palabras pretendido.)
kirbyfan64sos
5

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

lirtosiast
fuente
Esto me recuerda que TI-BASIC no admite listas de cadenas. Eso probablemente sería lo único que agregaría a TI-BASIC: P
Conor O'Brien el
4

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

falla
fuente
3

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!

ETHproductions
fuente
Probablemente pueda guardar algunos bytes utilizando el equivalente de Japt eval(U.join`+`).
Mama Fun Roll
Me encanta este idioma: D
fase
@ ן nɟuɐɯɹɐ ן oɯ Gracias, a pesar de que aún no he agregado un evalequivalente, ¡eso realmente ahorra un byte!
ETHproductions
2

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
Naouak
fuente
¿Es este un programa completo ...? ¿Qué genera los puntos a STDOUT ...? No parece así.
Yytsi
Tienes razón. Maldición, esto agregará muchos bytes,
Naouak
Voilà, fijo. casi 3 veces más ahora :(
Naouak
Hmm: / Sigo pensando que el objetivo es crear un hermoso arte de código que funcione bien. Y el código que proporcionó es muy complejo y atractivo. :) ¡Gracias por participar!
Yytsi
2

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 .

Dennis
fuente
Funciona para todas las entradas positivas, sin embargo, no genera nada cuando ingreso números negativos. ¿Los estoy ingresando en un formato incorrecto? 1J1 3J3 funciona. 0J-1 0J1 no. También intenté usar el símbolo menos superior para declarar la negatividad numérica.
Yytsi
@TuukkaX El alto menos en el camino a seguir. Obtengo salida 1 ¯1para entrada 0J¯1 0J1, que es la respuesta correcta. ¿Que estas obteniendo?
Dennis
1
Oh, ahora lo tengo funcionando. Solo tuve que eliminar el pequeño espacio en blanco antes del signo menos alto. Funciona y califica.
Yytsi
2

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.

Dennis
fuente
1

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.
Reto Koradi
fuente
1

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

Emigna
fuente
¿Lee esto de STDIN e imprime en STDOUT ...?
Yytsi
@ TuukkaX: Probablemente no. Toma entrada en forma de una consulta. Leí la parte que decía que la entrada podría ser el formato que quisiéramos. Me perdí la parte sobre STDIN. Ni siquiera estoy seguro de qué es STDIN en Prolog. ¿Lectura de entrada del usuario estaría bien?
Emigna
STDIN significa entrada estándar. Así que leer del usuario es el camino a seguir :) y por formato me refiero a la forma en que el usuario ingresa los valores. Ej [x, y] [x, y] o {x, y} ...
Yytsi
0

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

Mego
fuente
Haces algo mal, su cuenta de bytes subió con cada edición, pero trato de llevar el ByteCount hacia abajo con cada edición = P
flawr
8
@flawr Soy el anti-Dennis
Mego
Creo que todas las respuestas deben ser programas completos, que reciban información de STDIN (o la alternativa más cercana). ¿Esto califica?
ETHproductions
0

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)

TFeld
fuente