Willkommen zu meiner ersten Code-Golf-Challenge! :) Hüpfen wir gleich hinein.

Herausforderung:

Bei zwei gegebenen Gleitkommavektoren, O (Ursprung) und T (Ziel), müssen Sie ein Programm erstellen, um die Werte L und R auf STDOUT zu drucken.

1. O ist eine Ecke des Platzes
2. T ist eine Ecke des Quadrats, die sich gegenüber von O befindet
3. L ist der 2D-Punkt (Ecke), der den anderen Punkt des unvollständigen Quadrats markiert
4. R ist der 2D-Punkt (Ecke), der L gegenüberliegt

Regeln

5. Die Werte für O und T müssen aus STDIN gelesen werden (siehe Beispieleingaben).
6. Auch hier müssen die Werte von L und R auf STDOUT gedruckt werden.

Wertung und Boni

7. Zählen Sie die Bytes Ihres Programms.
8. Wenn Ihr Programm Linien zeichnet, die zwischen O , L , T und R liegen , subtrahieren Sie 15 Bytes von der Byteanzahl.

Beispiele

Die erste Zeile enthält Eingaben (erste eckige Klammern für O und nächste Klammern für T ) und die andere Zeile enthält die erwartete Ausgabe.

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

HINWEIS : Ein- und Ausgänge können Gleitkommawerte sein!

Wichtige Informationen!

• Die Werte O und T können in jedem beliebigen Format verwendet werden, sofern sie von STDIN stammen (z. B. Inside [] oder () ...). Verwenden Sie das gewünschte Format.
• L und R können in beliebiger Reihenfolge gedruckt werden.
• Denken Sie daran: Wenn (O-> L-> T-> R-> O) verbunden sind, muss jede Seite die gleiche Länge haben!

Gewinnen

• Dies ist Code-Golf, so dass nur die wenigsten Byteantworten gewinnen!
• Die Antwort des Gewinners wird am Sonntag, den 15.11.2015, zwischen 20:00 und 22:00 Uhr (finnische Zeit) entgegengenommen.

Viel Spaß beim Golfen!

Im Ernst , 11 Bytes

Ein Port meiner TI-BASIC Antwort. Berechnet mean(X)+i*(X-mean(X)).

,;Σ½;)±+ï*+

Erläuterung:

,           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

Eingabe als eine Liste von zwei komplexen Zahlen: [1-1j,4+2j]und die Ausgabe in dem gleichen Format [(4-1j), (1+2j)].

Im Ernst , 25 Bytes

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

Nimmt Eingaben als Liste: [x1,y1,x2,y2]

Gleiche Strategie wie meine Python-Antwort, aber im Ernst!

Erläuterung:

,      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

Probieren Sie es online aus

TI-BASIC, 16 Bytes

Für einen Taschenrechner der Serie TI-83 + oder 84+.

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

Sofern ich nichts falsch verstanden habe, sagte OP, dass es in Ordnung sei, Ein- und Ausgaben als komplexe Zahlen zu betrachten. Das ihier ist die imaginäre Einheit, nicht die Statistikvariable.

TI-BASIC hat eine mean(Funktion, funktioniert aber ärgerlicherweise nicht mit komplexen Listen ERR:DATA TYPE.

Eingabe in das Formular {1-i,4+2i}für [[1,-1],[4,2]]. Die Ausgabe erfolgt in der Form {4-i 1+2i}für [[1,2][4,-1]].

Matlab, 51 45 46 45 42 Bytes

Jetzt wird die Eingabe in einem Spaltenvektor erwartet: [x0;y0;x1;y1](Ausgabe im gleichen Format) Ich habe es so geändert, dass es ein vollständiges Programm ist.

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

Oder alternativ

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

Alte Lösung:

Die Eingabe erwartet Spaltenvektoren, z f([0;0],[3;3])

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

Es werden auch zwei Spaltenvektoren (als 2x2-Matrix) zurückgegeben.

Japt, 29 28 Bytes

Japt ist eine verkürzte Version von Ja vaScri pt . Dolmetscher

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

Beachten Sie, dass für die Pfeilfunktionen ein ES6-kompatibler Browser erforderlich ist, z. B. die neueren Versionen von Firefox. Die Eingabe erfolgt als Array mit 4 Elementen, z [1,-1,4,2].

Wie es funktioniert

         // 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

Wie es gespielt wurde

Ich habe zuerst versucht, einfach den @ Mego-Python-Ansatz zu kopieren. Dies ließ mich mit diesem 48-Byte-Monster zurück:
(Hinweis: Die Eingabe sollte derzeit nicht in ein Array eingeschlossen werden.)

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

Da jedes dieser Elemente durch 2 geteilt werden muss, ist es kürzer, das gesamte Array wie folgt abzubilden mY=>Y/2:

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

Was jetzt? Nun, das Array addiert einfach drei der Eingänge und subtrahiert den vierten, indem es dem Muster folgt 1,2,3,0. Wir könnten also die Eingaben in ein Array packen, sie dann addieren, durch 2 dividieren und das erforderliche Element subtrahieren:

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

Schön, ein Byte gespart! Aber ist es möglich, das Array am Anfang zu verkleinern? Lassen Sie uns versuchen, es in einen String zu packen und dann wieder in ein Array aufzuteilen a:

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

Schau dir das an, ein weiteres Byte gespeichert. Aber gibt es einen noch besseren Weg? Nun, wir können die Tatsache nutzen, dass [1,2,3,0] ≡ [1,2,3,4] mod 4:

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

Noch zwei Bytes! Jetzt gehen wir irgendwohin. Aber das Ug0 +Ug1 +Ug2 +Ug3kostet viel Platz. Was ist, wenn wir das Array durch Hinzufügen verkleinern?

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

Wow, das hat wirklich geholfen! Jetzt sind wir auf 29 Bytes reduziert. Und dank @ ן nןuɟ ן oן konnte ich sogar ein weiteres Byte weniger Golf spielen. Aber wenn wir ein eingebautes Array verwenden könnten, um das Array zu summieren, wäre es viel kürzer:

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

19 Bytes! Tolle! Leider verfügt Japt noch nicht über solche Einbauten. Ich werde das hinzufügen, wenn ich eine Chance bekomme. Vorschläge sind willkommen, entweder für das Programm oder die Sprache!

Nun, seit Version 1.4.4 habe ich eine ganze Reihe weiterer Funktionen in Japt implementiert, als ich ursprünglich geplant hatte. Beginnend mit dem ursprünglichen Plan für die kürzere Version:

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

Zuerst müssen wir ein paar Dinge ändern: Funktionen werden mit definiert {, und die Summenfunktion ist x. Diese Version funktioniert wie sie ist:

1o5 mZ{Ux /2-UgZ%4

Nun @ist eine Abkürzung für XYZ{, so dass wir ein Byte speichern , indem Sie von einem Wechsel Zzu X. Außerdem gibt £es eine Abkürzung zum m@Speichern eines weiteren Bytes:

1o5 £Ux /2-UgX%4

Kürzlich habe ich eine Funktion implementiert, bei der ein Uam Anfang des Programms normalerweise weggelassen werden kann. Aufgrund eines Implementierungsfehlers funktioniert dies jedoch auch mit Funktionen:

1o5 £x /2-UgX%4

Schließlich wird die gFunktion jetzt umbrochen, wenn der Index hinter dem Ende der Zeichenfolge liegt, sodass wir %4insgesamt 13 Byte entfernen können :

1o5 £x /2-UgX

Und ich fand 19 großartig ;-) Teste es online!

Javascript (Node.js / ES6), 154 Byte

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

Stdin zu bekommen ist der längere Teil des Codes. Die Eingabe sollte durch Kommas getrennt sein:

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

ngn APL, 21 Bytes

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

Dies nimmt die Eingabe als ein Paar komplexer Zahlen (z. B. 1J¯1 4J2) und druckt die Ausgabe auf die gleiche Weise (z 4J¯1 1J2. B. ). Probieren Sie es online in der ngn / apl-Demo aus .

Pyth, 12 Bytes

.jL.OQ-R.OQQ

Dies nimmt die Eingabe als ein Paar komplexer Zahlen (z. B. 1-1j, 4+2j) und druckt die Ausgabe als Array (z [(4-1j), (1+2j)]. B. ). Probieren Sie es online aus.

𝔼𝕊𝕄𝕚𝕟 29 Zeichen / 43 Bytes

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

Try it here (Firefox only).

CJam, 30 Bytes

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

Probieren Sie es online aus

Dies nimmt Eingaben als Liste von Listen entgegen, z. B. für das letzte Beispiel:

[[0 -1] [0 1]]

Erläuterung:

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.

Prolog, 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.

Etwas besser lesbar:

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.

So starten Sie das Programm:

p(X,Y).

Beispieleingabe, wenn die bekannten Ecken [1, -1] [4, 2] sind:
[1, -1,4,2]

Beispielausgabe, wobei X und Y die unbekannten Ecken enthalten:
X = [1,0, 2,0],
Y = [4.0, -1.0]

Probieren Sie es hier online aus

Bearbeiten: Geändert, um die Eingabe von STDIN zu lesen

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

Die Eingabe erfolgt im Formular x1 y1 x2 y2in einer einzelnen Zeile.

Probieren Sie es online aus

Python 2, 56 Bytes

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

Eingabe kann x1,y1,x2,y2oder sein(x1,y1,x2,y2)