Benvenuti nella mia prima sfida di code-golf! :) Saltiamoci dentro.

Sfida:

Dati due vettori in virgola mobile, O (origine) e T (destinazione), è necessario creare un programma per stampare i valori L e R su STDOUT.

1. O è un angolo della piazza
2. T è un angolo del quadrato che si trova di fronte a O
3. L è il punto 2D (angolo) che segna l'altro punto del quadrato incompleto
4. R è il punto 2D (angolo) che è opposto a L

Regole

5. I valori per O e T devono essere letti da STDIN (vedi input di esempio).
6. Ancora una volta, i valori di L e R devono essere stampati su STDOUT.

Punteggio e bonus

7. Conta i byte del tuo programma.
8. Se il programma disegna linee che si collegano tra O a L a T a R , sottrarre 15 byte dal conteggio dei byte.

Esempi

La prima riga copre gli input (le prime parentesi quadre per O e le parentesi successive per T ) e l'altra riga rappresenta l'output previsto.

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

AVVISO : gli ingressi e le uscite possono essere in virgola mobile!

Informazioni importanti!

• I valori O e T possono essere presi in qualsiasi formato, purché provengano da STDIN (es. Inside [] o () ...), usa qualunque formato tu voglia.
• L e R possono essere stampati in qualsiasi ordine.
• Ricorda: quando (O-> L-> T-> R-> O) sono collegati, ogni lato deve avere la stessa lunghezza!

vincente

• Questo è code-golf quindi vince il minor numero di byte!
• La risposta del vincitore verrà accettata domenica 15.11.2015 20: 00-22: 00 (ora della Finlandia) (se non sbaglio, quella data è scritta come l'11.15.2015 negli Stati Uniti, non confonderti).

Buon golf!

Scherzi a parte , 11 byte

Una porta della mia risposta TI-BASIC. Calcola mean(X)+i*(X-mean(X)).

,;Σ½;)±+ï*+

Spiegazione:

,           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

Ingresso come una lista di due numeri complessi: [1-1j,4+2j]e l'uscita nello stesso formato: [(4-1j), (1+2j)].

Scherzi a parte , 25 byte

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

Accetta input come elenco: [x1,y1,x2,y2]

Stessa strategia della mia risposta Python, ma in Seriamente!

Spiegazione:

,      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

Provalo online

TI-BASIC, 16 byte

Per una calcolatrice serie TI-83 + o 84+.

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

A meno che non abbia frainteso, OP ha detto che stavano bene prendendo input e output come numeri complessi. Il iqui è l'unità immaginaria, non la variabile statistica.

TI-BASIC ha una mean(funzione, ma fastidiosamente non funziona con elenchi complessi, lanciando un ERR:DATA TYPE.

Inserisci nel modulo {1-i,4+2i}per [[1,-1],[4,2]]. L'output è nel formato {4-i 1+2i}per [[1,2][4,-1]].

Matlab, 51 45 46 45 42 byte

Ora l'input è previsto in un vettore di colonna: [x0;y0;x1;y1](in uscita nello stesso formato) L'ho appena modificato per essere un programma completo.

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

O in alternativa

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

Vecchia soluzione:

L'ingresso prevede vettori di colonna, ad es f([0;0],[3;3])

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

Restituisce anche due vettori di colonna (come una matrice 2x2).

Japt, 29 28 byte

Japt è una versione abbreviata di Ja vaScri pt . Interprete

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

Si noti che le funzioni freccia richiedono un browser conforme a ES6, come le versioni più recenti di Firefox. L'ingresso entra in un array di 4 elementi, ad es [1,-1,4,2].

Come funziona

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

Come è stato giocato a golf

Per prima cosa ho provato semplicemente a copiare l'approccio Python di @ Mego. Questo mi ha lasciato con questo mostro a 48 byte:
(Nota: l'ingresso non dovrebbe essere attualmente racchiuso in un array.)

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

Poiché ciascuno di questi elementi deve essere diviso per 2, è più breve mappare l'intero array con mY=>Y/2:

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

E adesso? Bene, l'array ora sta semplicemente aggiungendo tre degli input e sottraendo il quarto, seguendo il modello 1,2,3,0. Quindi, potremmo raggruppare gli input in un array, quindi sommarli, dividerli per 2 e sottrarre l'elemento necessario:

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

Bello, risparmiato un byte! Ma è possibile ridurre l'array all'inizio? Proviamo a impacchettarlo in una stringa, quindi a dividerlo in un array con a:

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

Guarda quello, un altro byte salvato. Ma c'è un modo ancora migliore? Bene, possiamo usare il fatto che [1,2,3,0] ≡ [1,2,3,4] mod 4:

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

Altri due byte! Ora andiamo da qualche parte. Ma questo Ug0 +Ug1 +Ug2 +Ug3sta occupando molto spazio. E se riducessimo l'array con l'aggiunta?

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

Caspita, mi ha davvero aiutato! Ora siamo scesi a 29 byte. E grazie a @ ן nɟuɐɯɹɐ ן oɯ, sono stato anche in grado di golf un altro byte dalla riduzione. Ma se potessimo usare un built-in per sommare l'array, sarebbe molto più breve:

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

19 byte! Sorprendente! Sfortunatamente, Japt non ha ancora questi built-in. Lo aggiungerò quando ne avrò la possibilità. Suggerimenti sono ben accetti, sia per il programma che per la lingua!

Bene, a partire dalla v1.4.4, ho implementato in Japt alcune funzionalità in più rispetto a quanto inizialmente previsto. A partire dal piano originale per la versione più corta:

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

Per prima cosa dobbiamo cambiare alcune cose: le funzioni sono definite con {, e la funzione somma è x. Questa versione funziona così com'è:

1o5 mZ{Ux /2-UgZ%4

Ora, @è una scorciatoia per XYZ{, che ci consente di salvare un byte passando da Za X. Inoltre, £è una scorciatoia per il m@salvataggio di un altro byte:

1o5 £Ux /2-UgX%4

Di recente ho implementato una funzionalità in cui Ua all'inizio del programma di solito può essere esclusa. A causa di un errore di implementazione, tuttavia, funziona anche con le funzioni:

1o5 £x /2-UgX%4

Infine, la gfunzione ora termina se l'indice è oltre la fine della stringa, permettendoci di rimuovere il %4per un totale di 13 byte :

1o5 £x /2-UgX

E ho pensato che 19 fosse incredibile ;-) Provalo 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])))

Ottenere stdin è la parte più lunga del codice. L'input dovrebbe essere i punti separati da virgola:

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

APL ngn, 21 byte

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

Questo prende l'input come una coppia di numeri complessi (ad es. 1J¯1 4J2) E stampa l'output allo stesso modo (ad es 4J¯1 1J2.). Provalo online nella demo di ngn / apl .

Pyth, 12 byte

.jL.OQ-R.OQQ

Questo prende l'input come una coppia di numeri complessi (ad es. 1-1j, 4+2j) E stampa l'output come un array (ad es [(4-1j), (1+2j)].). Provalo online.

𝔼𝕊𝕄𝕚𝕟, 29 caratteri / 43 byte

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

Try it here (Firefox only).

CJam, 30 byte

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

Provalo online

Questo accetta input come un elenco di elenchi, ad esempio per l'ultimo esempio:

[[0 -1] [0 1]]

Spiegazione:

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 byte

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.

Leggermente più leggibile:

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.

Per avviare il programma:

p(X,Y).

Esempio di input quando gli angoli noti sono [1, -1] [4, 2]:
[1, -1,4,2]

Esempio di output, in cui X e Y conterranno gli angoli sconosciuti:
X = [1.0, 2.0],
Y = [4.0, -1.0]

Provalo online qui

Modifica: modificato per leggere l'input da STDIN

Python 3, 102 byte

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

L'input viene preso nella forma x1 y1 x2 y2, su una sola riga.

Provalo online

Python 2, 56 byte

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

L'ingresso può essere x1,y1,x2,y2o(x1,y1,x2,y2)