Witam na moim pierwszym konkursie golfa! :) Wskoczmy od razu.

Wyzwanie:

Biorąc pod uwagę dwa wektory zmiennoprzecinkowe, O (początek) i T (cel), musisz utworzyć program do drukowania wartości L i R na STDOUT.

1. O jest jednym rogiem kwadratu
2. T jest jednym rogiem kwadratu, który znajduje się naprzeciwko O
3. L jest punktem 2D (narożnikiem), który oznacza drugi punkt niepełnego kwadratu
4. R jest punktem 2D (narożnikiem), który jest przeciwny do L

Zasady

5. Wartości O i T należy odczytać ze STDIN (patrz przykładowe dane wejściowe).
6. Ponownie, wartości L i R należy wydrukować do STDOUT.

Punktacja i bonusy

7. Policz bajty swojego programu.
8. Jeśli twój program rysuje linie łączące O do L do T do R , odejmij 15 bajtów od liczby bajtów.

Przykłady

Pierwszy wiersz obejmuje dane wejściowe (pierwszy nawias kwadratowy dla O i następny nawias kwadratowy dla T ), a drugi wiersz reprezentuje oczekiwany wynik.

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

UWAGA : wejścia i wyjścia mogą być zmiennoprzecinkowe!

Ważna informacja!

• Wartości O i T można przyjmować w dowolnym formacie, o ile pochodzą one ze STDIN (np. Inside [] lub () ...), użyj dowolnego formatu.
• L i R można wydrukować w dowolnej kolejności.
• Pamiętaj: gdy (O-> L-> T-> R-> O) są połączone, każda strona musi mieć tę samą długość!

Zwycięski

• To jest golf golfowy, więc wygrywa najmniej bajtów!
• Odpowiedź zwycięzcy zostanie zaakceptowana w niedzielę 15.11.2015 20: 00-22: 00 (czas w Finlandii) (Jeśli się nie mylę, data ta jest zapisana jak 11.15.2015 w USA, nie mylcie się).

Miłej gry w golfa!

Poważnie , 11 bajtów

Port mojej odpowiedzi TI-BASIC. Oblicza mean(X)+i*(X-mean(X)).

,;Σ½;)±+ï*+

Wyjaśnienie:

,           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

Wejście w postaci listy dwóch liczb zespolonych: [1-1j,4+2j]i wyjście w tym samym formacie: [(4-1j), (1+2j)].

Poważnie , 25 bajtów

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

Pobiera dane wejściowe jako listę: [x1,y1,x2,y2]

Ta sama strategia jak moja odpowiedź w Pythonie, ale na poważnie!

Wyjaśnienie:

,      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

Wypróbuj online

TI-BASIC, 16 bajtów

Do kalkulatora serii TI-83 + lub 84+.

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

O ile nie zrozumiałem źle, OP stwierdził, że nie przeszkadza im przyjmowanie danych wejściowych i wyjściowych jako liczb zespolonych. iTutaj jest jednostką urojoną, nie zmienna statystyki.

TI-BASIC ma mean(funkcję, ale irytująco nie działa ze złożonymi listami, rzucając ERR:DATA TYPE.

Wprowadź w formularzu {1-i,4+2i}dla [[1,-1],[4,2]]. Wyjście jest w postaci {4-i 1+2i}o [[1,2][4,-1]].

Matlab, 51 45 46 45 42 bajtów

Teraz oczekuje się danych wejściowych w jednym wektorze kolumny: [x0;y0;x1;y1](wyjście w tym samym formacie) Właśnie zmodyfikowałem go, aby był pełnym programem.

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

Lub alternatywnie

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

Stare rozwiązanie:

Dane wejściowe oczekują wektorów kolumnowych, np f([0;0],[3;3])

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

Zwraca również dwa wektory kolumnowe (jako macierz 2x2).

Japt, 29 28 bajtów

Japt to skrócona wersja Ja vaScri pt . Interpretator

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

Pamiętaj, że funkcje strzałek wymagają przeglądarki zgodnej z ES6, takiej jak nowsze wersje Firefox. Dane wejściowe są w postaci tablicy 4-elementowej, np [1,-1,4,2].

Jak to działa

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

Jak było w golfa

Najpierw próbowałem po prostu skopiować podejście Python @ Mego. Zostawił mnie ten 48-bajtowy potwór:
(Uwaga: dane wejściowe nie powinny być obecnie zawinięte w tablicę).

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

Ponieważ każdy z tych elementów musi być podzielony przez 2, krótsze jest mapowanie całej tablicy za pomocą mY=>Y/2:

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

Co teraz? Cóż, tablica dodaje teraz trzy wejścia i odejmuje czwarte, zgodnie ze wzorcem 1,2,3,0. Możemy więc spakować dane wejściowe do tablicy, a następnie dodać je razem, podzielić przez 2 i odjąć niezbędny element:

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

Fajnie, uratowałem bajt! Ale czy można zmniejszyć tablicę na początku? Spróbujmy spakować go do łańcucha, a następnie podzielić go z powrotem na tablicę za pomocą a:

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

Spójrz na to, zapisano kolejny bajt. Ale czy jest jeszcze lepszy sposób? Możemy wykorzystać fakt, że [1,2,3,0] ≡ [1,2,3,4] mod 4:

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

Kolejne dwa bajty! Teraz gdzieś idziemy. Ale to Ug0 +Ug1 +Ug2 +Ug3zajmuje dużo miejsca. Co jeśli zmniejszymy tablicę z dodaniem?

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

Wow, to naprawdę pomogło! Teraz mamy do 29 bajtów. I dzięki @ ן nɟuɐɯɹɐ ן oɯ, byłem nawet w stanie zagrać w golfa o kolejny bajt poza redukcją. Ale jeśli moglibyśmy użyć wbudowanego do zsumowania tablicy, byłoby to znacznie krótsze:

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

19 bajtów! Niesamowity! Niestety, Japt nie ma jeszcze takich wbudowanych funkcji. Dodam to, kiedy będę miał szansę. Sugestie są mile widziane, zarówno dla programu, jak i dla języka!

Od wersji 1.4.4 w Japt zaimplementowałem o wiele więcej funkcji, niż pierwotnie planowałem. Począwszy od oryginalnego planu dla krótszej wersji:

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

Najpierw musimy zmienić kilka rzeczy: Funkcje są definiowane za pomocą {, a funkcja sumowania to x. Ta wersja działa jak jest:

1o5 mZ{Ux /2-UgZ%4

Teraz @jest to skrót XYZ{, który pozwala nam zaoszczędzić bajt, przechodząc z Zna X. Ponadto, £jest to skrót m@, oszczędność kolejny bajt:

1o5 £Ux /2-UgX%4

Niedawno wdrożyłem funkcję, w której Una początku programu można zwykle pominąć. Jednak z powodu błędu implementacji działa to również z funkcjami:

1o5 £x /2-UgX%4

Na koniec gfunkcja jest teraz zawijana, jeśli indeks znajduje się poza końcem ciągu, co pozwala nam usunąć %4łącznie 13 bajtów :

1o5 £x /2-UgX

I pomyślałem, że 19 jest niesamowity ;-) Przetestuj to online!

JavaScript (Node.js / ES6), 154 bajtów

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

Uzyskiwanie standardowego wejścia jest dłuższą częścią kodu. Dane wejściowe powinny być oddzielone przecinkami punktowymi:

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

ngn APL, 21 bajtów

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

Pobiera dane wejściowe jako parę liczb zespolonych (np. 1J¯1 4J2) I wypisuje dane wyjściowe w ten sam sposób (np 4J¯1 1J2.). Wypróbuj online w wersji demonstracyjnej ngn / apl .

Pyth, 12 bajtów

.jL.OQ-R.OQQ

Pobiera dane wejściowe jako parę liczb zespolonych (np. 1-1j, 4+2j) I wypisuje dane wyjściowe jako tablicę (np [(4-1j), (1+2j)].). Wypróbuj online.

𝔼𝕊𝕄𝕚𝕟, 29 znaków / 43 bajty

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

Try it here (Firefox only).

CJam, 30 bajtów

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

Wypróbuj online

Pobiera to dane wejściowe jako listę list, np. Dla ostatniego przykładu:

[[0 -1] [0 1]]

Wyjaśnienie:

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 bajtów

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.

Nieco bardziej czytelny:

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.

Aby uruchomić program:

p(X,Y).

Przykładowe dane wejściowe, gdy znanymi narożnikami są [1, -1] [4, 2]:
[1, -1,4,2]

Przykładowe dane wyjściowe, w których X i Y będą zawierać nieznane rogi:
X = [1.0, 2.0],
Y = [4.0, -1.0]

Wypróbuj tutaj online

Edycja: Zmieniono, aby czytać dane wejściowe ze STDIN

Python 3, 102 bajty

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

Dane wejściowe są pobierane w formie x1 y1 x2 y2, w jednym wierszu.

Wypróbuj online

Python 2, 56 bajtów

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

Dane wejściowe mogą być x1,y1,x2,y2lub(x1,y1,x2,y2)