Bienvenue à mon premier défi de golf de code! :) Allons droit au but.

Défi:

Étant donné deux vecteurs à virgule flottante, O (origine) et T (cible), vous devez créer un programme pour imprimer les valeurs L et R sur STDOUT.

1. O est un coin du carré
2. T est un coin du carré situé en face de O
3. L est le point 2D (coin) qui marque l'autre point du carré incomplet
4. R est le point 2D (coin) opposé à L

Règles

5. Les valeurs pour O et T doivent être lues à partir de STDIN (voir exemples d'entrées).
6. Encore une fois, les valeurs de L et R doivent être imprimées dans STDOUT.

Score et bonus

7. Comptez les octets de votre programme.
8. Si votre programme trace des lignes qui se connectent entre O à L à T à R , soustrayez 15 octets du nombre d'octets.

Exemples

La première ligne couvre les entrées (les premiers crochets pour O et les crochets suivants pour T ) et l'autre ligne représente la sortie attendue.

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

AVIS : les entrées et sorties peuvent être des virgules flottantes!

Une information important!

• Les valeurs O et T peuvent être prises dans n'importe quel format, tant qu'elles proviennent de STDIN (ex. Inside [] ou () ...), utilisez le format de votre choix.
• L et R peuvent être imprimés dans n'importe quel ordre.
• N'oubliez pas: lorsque (O-> L-> T-> R-> O) sont connectés, chaque côté doit avoir la même longueur!

Gagnant

• C'est le code-golf, donc le moins d'octets de réponses gagne!
• La réponse du gagnant sera acceptée le dimanche 15.11.2015 20: 00-22: 00 (heure de la Finlande) (Si je ne me trompe pas, cette date est écrite comme 11.15.2015 aux États-Unis, ne vous y trompez pas).

Bon golf!

Sérieusement , 11 octets

Un portage de ma réponse TI-BASIC. Calcule mean(X)+i*(X-mean(X)).

,;Σ½;)±+ï*+

Explication:

,           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

Entrée comme une liste de deux nombres complexes: [1-1j,4+2j]et la sortie dans le même format: [(4-1j), (1+2j)].

Sérieusement , 25 octets

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

Prend la saisie sous forme de liste: [x1,y1,x2,y2]

Même stratégie que ma réponse Python, mais sérieusement!

Explication:

,      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

Essayez-le en ligne

TI-BASIC, 16 octets

Pour une calculatrice TI-83 + ou 84+.

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

Sauf si j'ai mal compris, OP a dit qu'ils acceptaient bien de prendre les entrées et les sorties comme des nombres complexes. Le iest ici l'unité imaginaire, pas la variable statistique.

TI-BASIC a une mean(fonction, mais ennuyeusement, il ne fonctionne pas avec des listes complexes, jetant un ERR:DATA TYPE.

Entrez dans le formulaire {1-i,4+2i}pour [[1,-1],[4,2]]. La sortie est au format {4-i 1+2i}pour [[1,2][4,-1]].

Matlab, 51 45 46 45 42 octets

Maintenant, l'entrée est attendue dans un vecteur de colonne: [x0;y0;x1;y1](sortie dans le même format) Je viens de la modifier pour qu'elle soit un programme complet.

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

Ou bien

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

Ancienne solution:

L'entrée attend des vecteurs de colonne, par exemple f([0;0],[3;3])

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

Il renvoie également deux vecteurs de colonne (sous forme de matrice 2x2).

Japt, 29 28 octets

Japt est une version raccourcie de Ja vaScri pt . Interprète

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

Notez que les fonctions fléchées nécessitent un navigateur compatible ES6, comme les nouvelles versions de Firefox. L'entrée entre dans un tableau de 4 éléments, par exemple [1,-1,4,2].

Comment ça fonctionne

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

Comment il a été joué au golf

J'ai d'abord essayé de copier simplement l'approche Python de @ Mego. Cela m'a laissé avec ce monstre de 48 octets:
(Remarque: l'entrée ne doit pas actuellement être enveloppée dans un tableau.)

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

Étant donné que chacun de ces éléments doit être divisé par 2, il est plus court de mapper l'ensemble du tableau avec mY=>Y/2 :

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

Maintenant quoi? Eh bien, le tableau ajoute simplement trois des entrées et soustrait la quatrième, en suivant le modèle1,2,3,0 . Ainsi, nous pourrions regrouper les entrées dans un tableau, puis les additionner, diviser par 2 et soustraire l'élément nécessaire:

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

Nice, sauvé un octet! Mais est-il possible de réduire le tableau au début? Essayons de le compresser dans une chaîne, puis de le diviser en un tableau aveca :

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

Regardez ça, un autre octet enregistré. Mais existe-t-il un meilleur moyen? Eh bien, nous pouvons utiliser le fait que[1,2,3,0] ≡ [1,2,3,4] mod 4 :

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

Encore deux octets! Maintenant, nous allons quelque part. Mais çaUg0 +Ug1 +Ug2 +Ug3 accapare beaucoup d'espace. Et si nous réduisions le tableau avec addition?

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

Wow, ça a vraiment aidé! Nous en sommes maintenant à 29 octets. Et grâce à @ ן nɟuɐɯɹɐ ן oɯ, j'ai même pu jouer un autre octet sur la réduction. Mais si nous pouvions utiliser un intégré pour additionner le tableau, ce serait beaucoup plus court:

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

19 octets! Incroyable! Malheureusement, Japt ne dispose pas encore de tels modules intégrés. J'ajouterai cela quand j'aurai une chance. Les suggestions sont les bienvenues, pour le programme ou la langue!

Eh bien, depuis la version 1.4.4, j'ai implémenté dans Japt un peu plus de fonctionnalités que je ne l'avais prévu à l'origine. En commençant par le plan d'origine pour la version plus courte:

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

Nous devons d'abord changer quelques éléments: les fonctions sont définies avec {et la fonction somme estx . Cette version fonctionne telle quelle:

1o5 mZ{Ux /2-UgZ%4

Maintenant, @est un raccourci pour XYZ{, nous permettant d'économiser un octet en passant de Zà X. Est également £un raccourci pourm@ enregistrer un autre octet:

1o5 £Ux /2-UgX%4

Récemment, j'ai implémenté une fonctionnalité où un Uau début du programme peut généralement être omis. Cependant, en raison d'une erreur d'implémentation, cela fonctionne également avec les fonctions:

1o5 £x /2-UgX%4

Enfin, la gfonction encapsule maintenant si l'index dépasse la fin de la chaîne, ce qui nous permet de supprimer le %4pour un total de 13 octets :

1o5 £x /2-UgX

Et je pensais que 19 était incroyable ;-) Testez-le en ligne!

Javascript (Node.js / ES6), 154 octets

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

Obtenir stdin est la partie la plus longue du code. L'entrée doit être les points séparés par une virgule:

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

ngn APL, 21 octets

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

Cela prend l'entrée comme une paire de nombres complexes (par exemple, 1J¯1 4J2) et imprime la sortie de la même manière (par exemple, 4J¯1 1J2). Essayez-le en ligne dans la démo ngn / apl .

Pyth, 12 octets

.jL.OQ-R.OQQ

Cela prend l'entrée comme une paire de nombres complexes (par exemple, 1-1j, 4+2j) et imprime la sortie comme un tableau (par exemple, [(4-1j), (1+2j)]). Essayez-le en ligne.

𝔼𝕊𝕄𝕚𝕟, 29 caractères / 43 octets

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

Try it here (Firefox only).

CJam, 30 octets

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

Essayez-le en ligne

Cela prend l'entrée comme une liste de listes, par exemple pour le dernier exemple:

[[0 -1] [0 1]]

Explication:

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 octets

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.

Un peu plus lisible:

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.

Pour démarrer le programme:

p(X,Y).

Exemple d'entrée lorsque les coins connus sont [1, -1] [4, 2]:
[1, -1,4,2]

Exemple de sortie, où X et Y contiendront les coins inconnus:
X = [1.0, 2.0],
Y = [4.0, -1.0]

Essayez-le en ligne ici

Modifier: Changé pour lire l'entrée de STDIN

Python 3, 102 octets

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'entrée est prise sous la forme x1 y1 x2 y2 , sur une seule ligne.

Essayez-le en ligne

Python 2, 56 octets

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

L'entrée peut être x1,y1,x2,y2ou(x1,y1,x2,y2)