Chào mừng bạn đến với thử thách chơi gôn mã đầu tiên của tôi! :) Hãy nhảy ngay vào nó.

Thử thách:

Cho hai vectơ dấu phẩy động là O (gốc) và T (đích), bạn phải tạo một chương trình để in các giá trị L và R thành STDOUT.

1. O là một góc của hình vuông
2. T là một góc của hình vuông nằm đối diện với O
3. L là điểm 2D (góc) đánh dấu điểm khác của hình vuông không hoàn chỉnh
4. R là điểm 2D (góc) đối diện với L

Quy tắc

5. Các giá trị cho O và T phải được đọc từ STDIN (xem ví dụ đầu vào).
6. Một lần nữa, giá trị của L và R phải được in thành STDOUT.

Ghi điểm và thưởng

7. Đếm các byte của chương trình của bạn.
8. Nếu chương trình của bạn vẽ các đường nối từ O đến L đến T đến R , hãy trừ 15 byte khỏi số byte.

Ví dụ

Dòng đầu tiên bao gồm các đầu vào (dấu ngoặc vuông đầu tiên cho O và dấu ngoặc tiếp theo cho T ) và dòng khác biểu thị đầu ra dự kiến.

• [0, 0] [3, 3] Dự kiến: [0, 3] [3, 0]
• [0, 0] [-2, -2] Dự kiến: [-2, 0] [0, -2]
• [1, -1] [4, 2] Dự kiến: [1, 2] [4, -1]
• [0, -1] [0, 1] Dự kiến: [-1, 0] [1, 0]

THÔNG BÁO : đầu vào và đầu ra có thể là điểm nổi!

Thông tin quan trọng!

• Các giá trị O và T có thể được thực hiện ở bất kỳ định dạng nào, miễn là chúng đến từ STDIN (ví dụ: Bên trong [] hoặc () ...), sử dụng bất kỳ định dạng nào bạn muốn.
• L và R có thể được in theo thứ tự bất kỳ.
• Hãy nhớ rằng: khi (O-> L-> T-> R-> O) được kết nối, mỗi bên phải có cùng độ dài!

Chiến thắng

• Đây là mã golf để câu trả lời byte ít nhất sẽ thắng!
• Câu trả lời của người chiến thắng sẽ được chấp nhận vào chủ nhật 15.11.2015 20: 00-22: 00 (giờ Phần Lan) (Nếu tôi không sai, ngày đó được viết như ngày 11.15.2015 tại Hoa Kỳ, đừng nhầm lẫn).

Chúc bạn chơi golf vui vẻ!

Nghiêm túc , 11 byte

Một cổng của câu trả lời TI-BASIC của tôi. Tính toán mean(X)+i*(X-mean(X)).

,;Σ½;)±+ï*+

Giải trình:

,           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

Nhập dưới dạng danh sách hai số phức: [1-1j,4+2j]và đầu ra có cùng định dạng : [(4-1j), (1+2j)].

Nghiêm túc , 25 byte

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

Đưa đầu vào dưới dạng danh sách: [x1,y1,x2,y2]

Chiến lược tương tự như câu trả lời Python của tôi, nhưng trong Nghiêm túc!

Giải trình:

,      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

Dùng thử trực tuyến

TI-BASIC, 16 byte

Đối với máy tính sê-ri TI-83 + hoặc 84+.

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

Trừ khi tôi hiểu lầm, OP nói rằng họ vẫn ổn khi lấy đầu vào và đầu ra là số phức. Đây ilà đơn vị tưởng tượng, không phải là biến thống kê.

TI-BASIC có một mean(chức năng, nhưng thật khó chịu là nó không hoạt động với các danh sách phức tạp, ném một ERR:DATA TYPE.

Đầu vào dưới dạng {1-i,4+2i}cho [[1,-1],[4,2]]. Đầu ra ở dạng {4-i 1+2i}cho [[1,2][4,-1]].

Matlab, 51 45 46 45 42 byte

Bây giờ đầu vào được mong đợi trong một vectơ cột: [x0;y0;x1;y1](ouput trong cùng định dạng) Tôi chỉ sửa đổi nó thành một chương trình đầy đủ.

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

Hay cách khác

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

Giải pháp cũ:

Đầu vào mong đợi các vectơ cột, ví dụ f([0;0],[3;3])

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

Nó cũng trả về hai vectơ cột (dưới dạng ma trận 2x2).

Japt, 29 28 byte

Japt là phiên bản rút gọn của Ja vaScri pt . Thông dịch viên

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

Lưu ý rằng các chức năng mũi tên yêu cầu trình duyệt tương thích ES6, chẳng hạn như các phiên bản Firefox mới hơn. Đầu vào đi vào như một mảng 4 mục, ví dụ [1,-1,4,2].

Làm thế nào nó hoạt động

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

Làm thế nào nó được chơi golf

Lần đầu tiên tôi thử đơn giản là sao chép cách tiếp cận Python của @ Mego. Điều này để lại cho tôi con quái vật 48 byte này:
(Lưu ý: hiện tại đầu vào không nên được bọc trong một mảng.)

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

Vì mỗi mục này cần được chia cho 2, nên ngắn hơn để ánh xạ toàn bộ mảng với mY=>Y/2:

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

Giờ thì sao? Chà, mảng bây giờ chỉ đơn giản là thêm ba trong số các đầu vào và trừ đi thứ tư, theo mẫu 1,2,3,0. Vì vậy, chúng ta có thể đóng gói các đầu vào thành một mảng, sau đó cộng chúng lại với nhau, chia cho 2 và trừ đi mục cần thiết:

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

Đẹp, tiết kiệm một byte! Nhưng có thể thu nhỏ mảng lúc đầu không? Hãy thử đóng gói thành một chuỗi, sau đó chia lại thành một mảng với a:

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

Nhìn vào đó, một byte khác được lưu. Nhưng có một cách thậm chí tốt hơn? Chà, chúng ta có thể sử dụng thực tế rằng [1,2,3,0] ≡ [1,2,3,4] mod 4:

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

Hai byte nữa! Bây giờ chúng ta sẽ đi đâu đó. Nhưng đó Ug0 +Ug1 +Ug2 +Ug3là rất nhiều không gian. Điều gì xảy ra nếu chúng ta giảm mảng với phép cộng?

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

Wow, điều đó thực sự có ích! Bây giờ chúng tôi xuống còn 29 byte. Và nhờ có @ nɟuɐɯɹɐ oɯ, tôi thậm chí còn có thể giảm được một byte khác. Nhưng nếu chúng ta có thể sử dụng một tích hợp để tổng hợp mảng, thì nó sẽ ngắn hơn:

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

19 byte! Kinh ngạc! Thật không may, Japt chưa có bất kỳ tích hợp nào như vậy. Tôi sẽ thêm cái này vào khi tôi có cơ hội. Đề xuất được chào đón, cho chương trình hoặc ngôn ngữ!

Chà, kể từ v1.4.4, tôi đã triển khai khá nhiều tính năng vào Japt so với dự định ban đầu. Bắt đầu với kế hoạch ban đầu cho phiên bản ngắn hơn:

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

Đầu tiên chúng ta cần thay đổi một vài điều: Hàm được định nghĩa {và hàm sum là x. Phiên bản này hoạt động như hiện trạng:

1o5 mZ{Ux /2-UgZ%4

Bây giờ, @là một tốc ký XYZ{, cho phép chúng ta lưu một byte bằng cách chuyển từ Zsang X. Ngoài ra, £là một phím tắt cho m@, lưu một byte khác:

1o5 £Ux /2-UgX%4

Gần đây tôi đã triển khai một tính năng mà Uở đầu chương trình thường có thể bị bỏ qua. Do một lỗi thực thi, tuy nhiên, điều này cũng hoạt động với các chức năng:

1o5 £x /2-UgX%4

Cuối cùng, ghàm bây giờ sẽ kết thúc nếu chỉ mục vượt quá cuối chuỗi, cho phép chúng ta loại bỏ %4tổng cộng 13 byte :

1o5 £x /2-UgX

Và tôi nghĩ 19 thật tuyệt vời ;-) Kiểm tra trực tuyến!

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

Bắt stdin là phần dài hơn của mã. Đầu vào phải là các điểm được phân tách bằng dấu phẩy:

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

APL, 21 byte

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

Cái này lấy đầu vào là một cặp số phức (ví dụ 1J¯1 4J2:) và in đầu ra theo cùng một cách (ví dụ 4J¯1 1J2:). Hãy thử trực tuyến trong bản demo ngn / apl .

Bình thường, 12 byte

.jL.OQ-R.OQQ

Cái này lấy đầu vào là một cặp số phức (ví dụ 1-1j, 4+2j:) và in đầu ra dưới dạng một mảng (ví dụ [(4-1j), (1+2j)]:). Hãy thử trực tuyến.

, 29 ký tự / 43 byte

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

Try it here (Firefox only).

CJam, 30 byte

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

Dùng thử trực tuyến

Điều này lấy đầu vào là một danh sách các danh sách, ví dụ cho ví dụ cuối cùng:

[[0 -1] [0 1]]

Giải trình:

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.

Hơi dễ đọc hơn:

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.

Để bắt đầu chương trình:

p(X,Y).

Ví dụ đầu vào khi các góc đã biết là [1, -1] [4, 2]:
[1, -1,4,2]

Đầu ra ví dụ, trong đó X và Y sẽ chứa các góc chưa biết:
X = [1.0, 2.0],
Y = [4.0, -1.0]

Dùng thử trực tuyến tại đây

Chỉnh sửa: Thay đổi để đọc đầu vào từ 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())))

Đầu vào được lấy theo mẫu x1 y1 x2 y2, trên một dòng duy nhất.

Dùng thử trực tuyến

Python 2, 56 byte

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

Đầu vào có thể x1,y1,x2,y2hoặc(x1,y1,x2,y2)