Ласкаво просимо на мій перший виклик-гольф! :) Давайте скачемо прямо в це.

Виклик:

Враховуючи два вектори з плаваючою точкою, O (початок) і T (цільовий), ви повинні створити програму для друку значень L і R для STDOUT.

1. O - один кут квадрата
2. Т - один кут квадрата, який розташований навпроти О
3. L - точка 2D (кут), що позначає іншу точку неповного квадрата
4. R - 2D-точка (кут), протилежна L

Правила

5. Значення для O і T слід зчитувати з STDIN (див. Приклади входів).
6. Знову ж, значення L і R повинні бути надруковані в STDOUT.

Зарахування та бонуси

7. Порахуйте байти програми.
8. Якщо ваша програма малює лінії, які з'єднуються від O до L до T до R , відніміть 15 байт від кількості байтів.

Приклади

Перший рядок охоплює входи (перша квадратна дужка для O і наступна дужка для T ), а інша лінія представляє очікуваний вихід.

• [0, 0] [3, 3] Очікується: [0, 3] [3, 0]
• [0, 0] [-2, -2] Очікується: [-2, 0] [0, -2]
• [1, -1] [4, 2] Очікується: [1, 2] [4, -1]
• [0, -1] [0, 1] Очікується: [-1, 0] [1, 0]

УВАГА : входи та виходи можуть бути плаваючими точками!

Важлива інформація!

• Значення O і T можна приймати в будь-якому форматі, якщо вони походять зі STDIN (наприклад, всередині [] або () ...), використовуйте будь-який формат, який ви хочете.
• L і R можна надрукувати в будь-якому порядку.
• Пам'ятайте: коли (O-> L-> T-> R-> O) з'єднані, кожна сторона повинна мати однакову довжину!

Перемога

• Це кодовий гольф, так що найменший байт відповіді виграє!
• Відповідь переможця буде прийнята в неділю 15.11.2015 20: 00-22: 00 (за фінським часом) (Якщо я не помиляюся, ця дата пишеться як 15.11.2015 у США, не плутайтесь).

Щасливого гольфу!

Серйозно , 11 байт

Порт моєї відповіді TI-BASIC. Розраховує mean(X)+i*(X-mean(X)).

,;Σ½;)±+ï*+

Пояснення:

,           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

Введення в вигляді списку з двох комплексних чисел: [1-1j,4+2j]і вихід в тому ж форматі: [(4-1j), (1+2j)].

Серйозно , 25 байт

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

Вводиться як список: [x1,y1,x2,y2]

Та ж стратегія, що і моя відповідь Python, але серйозно!

Пояснення:

,      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

Спробуйте в Інтернеті

TI-BASIC, 16 байт

Для калькулятора серії TI-83 + або 84+.

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

Якщо я неправильно зрозумів, ОП сказала, що вони в порядку, якщо вводити та виводити їх як складні числа. iТут уявна одиниця, а не буде змінена статистика.

TI-BASIC має mean(функцію, але прикро не працює зі складними списками, кидаючи ERR:DATA TYPE.

Введіть у формі {1-i,4+2i}для [[1,-1],[4,2]]. Вихід у формі {4-i 1+2i}для [[1,2][4,-1]].

Матлаб, 51 45 46 45 42 байт

Тепер вхід очікується в одному стовпчиковому векторі: [x0;y0;x1;y1](вихід у тому ж форматі) Я просто змінив його на повну програму.

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

Або в якості альтернативи

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

Старе рішення:

Вхід очікує векторів стовпців, наприклад f([0;0],[3;3])

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

Він також повертає два вектори стовпців (як матриця 2x2).

Japt, 29 28 байт

Japt - скорочена версія Ja vaScri pt . Перекладач

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

Зауважте, що для функцій зі стрілками потрібен браузер, сумісний із ES6, наприклад, новіші версії Firefox. Введення надходить як 4-елементний масив, наприклад [1,-1,4,2].

Як це працює

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

Як це було в гольф

Я спершу спробував просто скопіювати підхід @ Mego's Python. Це залишило мене з цим 48-байтовим монстром:
(Примітка: вхід зараз не повинен бути загорнутий у масив.)

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

Оскільки кожен з цих елементів потрібно розділити на 2, коротше зіставити весь масив за допомогою mY=>Y/2:

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

А тепер що? Ну а тепер масив просто додає три входи і віднімає четвертий, слідуючи шаблону 1,2,3,0. Отже, ми могли б запакувати вхідні дані в масив, а потім додати їх разом, розділити на 2 та відняти необхідний елемент:

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

Приємно, збережений байт! Але чи можна скоротити масив на початку? Давайте спробуємо упакувати його в рядок, а потім розділити його назад на масив за допомогою a:

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

Подивіться, що ще один байт збережено. Але чи є ще кращий спосіб? Що ж, ми можемо використати той факт, що [1,2,3,0] ≡ [1,2,3,4] mod 4:

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

Ще два байти! Зараз ми кудись їдемо. Але Ug0 +Ug1 +Ug2 +Ug3це дуже багато місця. Що робити, якщо ми зменшимо масив за допомогою додавання?

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

Ого, це справді допомогло! Тепер ми знизилися до 29 байт. І завдяки @ ן nɟuɐɯɹɐ ן oɯ, мені вдалося навіть покатати ще один байт за скорочення. Але якби ми могли використати вбудований підсумок для масиву, це було б набагато коротше:

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

19 байт! Дивовижний! На жаль, у компанії Japt ще немає таких вбудованих програм. Я додам це, коли отримаю можливість. Пропозиції вітаються як для програми, так і для мови!

Що ж, з версії 1.4.4, я реалізував у Japt зовсім більше функцій, ніж спочатку планував. Починаючи з початкового плану для коротшої версії:

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

Спочатку нам потрібно змінити кілька речей: Функції визначаються за допомогою {, а функція сума - x. Ця версія працює як є:

1o5 mZ{Ux /2-UgZ%4

Тепер @це скорочення XYZ{, що дозволяє нам зберегти байт, перейшовши Zна X. Також £є ярликом для m@збереження іншого байта:

1o5 £Ux /2-UgX%4

Нещодавно я реалізував функцію, за якою Uна початку програми зазвичай можна залишатись. Однак через помилку впровадження це також працює з функціями:

1o5 £x /2-UgX%4

Нарешті, gтепер функція завершується, якщо індекс минув кінець рядка, що дозволяє нам видалити значення %4в цілому 13 байтів :

1o5 £x /2-UgX

І я подумав, що 19 було дивовижним ;-) Перевірте це в Інтернеті!

Javascript (Node.js / ES6), 154 байти

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 - це довша частина коду. Вхідні дані повинні бути розділені комами:

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

ngn APL, 21 байт

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

Це сприймає вхід як пару складних чисел (наприклад, 1J¯1 4J2) і друкує вихід таким же чином (наприклад, 4J¯1 1J2). Спробуйте в Інтернеті в демонстрації ngn / apl .

Pyth, 12 байт

.jL.OQ-R.OQQ

Це сприймає вхід як пару складних чисел (наприклад, 1-1j, 4+2j) і друкує вихід у вигляді масиву (наприклад, [(4-1j), (1+2j)]). Спробуйте в Інтернеті.

𝔼𝕊𝕄𝕚𝕟, 29 символів / 43 байти

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

Try it here (Firefox only).

CJam, 30 байт

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

Спробуйте в Інтернеті

Це сприймає дані як список списків, наприклад, для останнього прикладу:

[[0 -1] [0 1]]

Пояснення:

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.

Пролог, 118 байт

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.

Трохи легше читати:

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.

Щоб запустити програму:

p(X,Y).

Приклад введення, коли відомими кутами є [1, -1] [4, 2]:
[1, -1,4,2]

Приклад виведення, де X і Y будуть містити невідомі кути:
X = [1.0, 2.0],
Y = [4.0, -1.0]

Спробуйте це онлайн тут

Редагувати: Змінено, щоб прочитати вхід зі STDIN

Python 3, 102 байти

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

Введення приймається у формі x1 y1 x2 y2, в одному рядку.

Спробуйте в Інтернеті

Python 2, 56 байт

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

Введення може бути x1,y1,x2,y2або(x1,y1,x2,y2)