İlk kod-golf mücadeleme hoş geldiniz! :) Hemen içine atlayalım.

Meydan okuma:

O (başlangıç noktası ) ve T (hedef) olmak üzere iki kayan nokta vektörü verildiğinde, L ve R değerlerini STDOUT'a yazdırmak için bir program oluşturmanız gerekir .

1. O karenin bir köşesi
2. T , O'nun karşısında yer alan karenin bir köşesidir.
3. L , eksik karenin diğer noktasını işaretleyen 2D noktadır (köşe)
4. R , L' nin karşısında olan 2B noktadır (köşe).

kurallar

5. O ve T değerleri STDIN'den okunmalıdır (örnek girişlere bakın).
6. Yine, L ve R değerleri STDOUT'a yazdırılmalıdır.

Puanlama ve bonuslar

7. Programınızın baytlarını sayın.
8. Programınız O ila L ila T ila R arasında bağlanan çizgiler çiziyorsa, bayt sayımından 15 bayt çıkarın.

Örnekler

İlk satır girişleri ( O için ilk köşeli ayraçlar ve T için sonraki köşeli ayraçlar ) ve diğer satır beklenen çıktıyı temsil eder.

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

DİKKAT : girişler ve çıkışlar kayan noktalar olabilir!

Önemli bilgi!

• Değerler O ve T yeter ki STDIN gelen gibi herhangi bir formatta alınabilir özellikleri (ör. İçini [] veya () ...), ne istersen biçimi kullanımını.
• L ve R herhangi bir sırada yazdırılabilir.
• Unutmayın: (O-> L-> T-> R-> O) bağlandığında, her iki tarafın da aynı uzunlukta olması gerekir!

Kazanan

• Bu kod golf kadar az bayt cevap kazanır!
• Kazanan cevap Pazar günü kabul edilecektir 15.11.2015 20: 00-22: 00 (Finlandiya saati) (Eğer yanlış değilsem, bu tarih ABD'de 11.15.2015 gibi yazılır, karıştırmayın).

Mutlu golf!

Ciddi , 11 bayt

TI-BASIC cevabımın bir limanı. Hesaplar mean(X)+i*(X-mean(X)).

,;Σ½;)±+ï*+

Açıklama:

,           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

: İki karmaşık sayılar listesi olarak giriş [1-1j,4+2j]aynı biçimde ve çıkışı: [(4-1j), (1+2j)].

Ciddi , 25 bayt

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

Girişi liste olarak alır: [x1,y1,x2,y2]

Python cevabımla aynı strateji, ama Cidden!

Açıklama:

,      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

Çevrimiçi deneyin

TI-BASIC, 16 bayt

TI-83 + veya 84+ serisi hesap makinesi için.

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

Yanlış anlamadığım sürece OP, girdi ve çıktıları karmaşık sayılar olarak almakta iyi olduklarını söyledi. iBurada hayali birim, değil istatistik değişkendir.

TI-BASIC'in bir mean(işlevi vardır, ancak can sıkıcı bir şekilde karmaşık listelerle çalışmaz ERR:DATA TYPE.

Şeklinde Girdi {1-i,4+2i}için [[1,-1],[4,2]]. Çıktı {4-i 1+2i}için [[1,2][4,-1]].

Matlab, 51 45 46 45 42 bayt

Şimdi girdi bir sütun vektörü bekleniyor: [x0;y0;x1;y1](aynı formatta çıkış) Ben sadece tam bir program olarak değiştirdim.

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

Veya alternatif olarak

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

Eski çözüm:

Giriş, sütun vektörlerini bekler, örn. f([0;0],[3;3])

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

Ayrıca iki sütun vektörü döndürür (2x2 matrisi olarak).

Japt, 29 28 bayt

Japt kısaltılmış versiyonudur Ja vaScri nk . yorumlayıcı

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

Ok işlevlerinin, Firefox'un daha yeni sürümleri gibi ES6 uyumlu bir tarayıcı gerektirdiğini unutmayın. Giriş, 4 öğeli bir dizi olarak girilir, örn [1,-1,4,2].

Nasıl çalışır

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

Nasıl Golf Yapıldı

İlk önce @ Mego'nun Python yaklaşımını kopyalamayı denedim. Bu beni 48 baytlık bir canavara bıraktı:
(Not: giriş şu anda bir diziye sarılmamalıdır.)

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

Bu öğelerin her birinin 2'ye bölünmesi gerektiğinden, dizinin tamamını aşağıdakilerle eşleştirmek daha kısadır mY=>Y/2:

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

Şimdi ne olacak? Dizi şimdi sadece üç giriş ekliyor ve dördüncüyü çıkarıyor, deseni izliyor 1,2,3,0. Böylece, girdileri bir diziye paketleyebilir, ardından bunları ekleyebilir, 2'ye bölebilir ve gerekli öğeyi çıkarabiliriz:

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

Güzel, bayt kurtardı! Ama diziyi başlangıçta küçültmek mümkün mü? Bir dizeye paketlemeyi deneyelim, ardından aşağıdakilerle bir diziye bölelim a:

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

Şuna bak, başka bir bayt kurtardı. Ama daha iyi bir yol var mı? Aslında şu gerçeği kullanabiliriz [1,2,3,0] ≡ [1,2,3,4] mod 4:

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

İki bayt daha! Şimdi bir yere gidiyoruz. Ama bu Ug0 +Ug1 +Ug2 +Ug3çok yer kaplıyor. Diziyi ekleyerek azaltırsak ne olur?

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

Vay canına, bu gerçekten yardımcı oldu! Şimdi 29 bayta düştük. Ve @ ן nɟuɐɯɹɐ ן oɯ sayesinde, indirimden başka bir bayt golf bile yapabildim. Ancak diziyi toplamak için yerleşik bir araç kullanabilirsek, çok daha kısa olurdu:

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

19 bayt! İnanılmaz! Ne yazık ki, Japt'te henüz böyle bir yerleşik yok. Şansım olduğunda bunu ekleyeceğim. Program veya dil için önerilerinizi bekliyoruz!

V1.4.4 itibariyle, Japt'e aslında planladığımdan biraz daha fazla özellik uyguladım. Kısa versiyonun orijinal planından başlayarak:

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

İlk olarak birkaç şeyi değiştirmemiz gerekir: Fonksiyonlar ile tanımlanır {ve sum fonksiyonu ile x. Bu sürüm olduğu gibi çalışır:

1o5 mZ{Ux /2-UgZ%4

Şimdi, @bir kısaltmadır XYZ{bize geçiş yaparak bir byte kaydetmek için izin Ziçin X. Ayrıca, başka bir bayt kaydetmek £için bir kısayoldur m@:

1o5 £Ux /2-UgX%4

Son zamanlarda U, programın başında a genellikle dışarıda bırakılabilir bir özellik uyguladım . Bununla birlikte, bir uygulama hatası nedeniyle, bu işlevlerle de çalışır:

1o5 £x /2-UgX%4

Son olarak, gişlev dizinin dizenin sonunu geçip geçmediğini sararak %4toplam 13 bayt için kaldırmamızı sağlar :

1o5 £x /2-UgX

Ve 19 muhteşem olduğunu düşündüm ;-) Çevrimiçi test edin!

Javascript (Node.js / ES6), 154 bayt

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 almak kodun daha uzun kısmıdır. Giriş virgülle ayrılmış noktalar olmalıdır:

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

ngn APL, 21 bayt

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

Bu, girdiyi bir çift karmaşık sayı (örn. 1J¯1 4J2) Olarak alır ve çıktıyı aynı şekilde yazdırır (örn 4J¯1 1J2.). Ngn / apl demosunda çevrimiçi deneyin .

Pyth, 12 bayt

.jL.OQ-R.OQQ

Bu, girdiyi bir çift karmaşık sayı (örn. 1-1j, 4+2j) Olarak alır ve çıktıyı bir dizi (örneğin, [(4-1j), (1+2j)]) olarak yazdırır . Çevrimiçi deneyin.

𝔼𝕊𝕄𝕚𝕟, 29 karakter / 43 bayt

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

Try it here (Firefox only).

CJam, 30 bayt

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

Çevrimiçi deneyin

Bu, girdiyi bir liste listesi olarak alır, örneğin son örnek için:

[[0 -1] [0 1]]

Açıklama:

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 bayt

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.

Biraz daha okunabilir:

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.

Programı başlatmak için:

p(X,Y).

Bilinen köşeler [1, -1] [4, 2] olduğunda örnek girdi:
[1, -1,4,2]

Örnek çıktı, burada X ve Y bilinmeyen köşeleri içerecektir:
X = [1.0, 2.0],
Y = [4.0, -1.0]

Çevrimiçi olarak buradan deneyin

Düzenleme: STDIN girişini okumak için değiştirildi

Python 3, 102 bayt

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

Giriş, x1 y1 x2 y2tek bir satıra formda alınır .

Çevrimiçi deneyin

Python 2, 56 bayt

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

Giriş olabilir x1,y1,x2,y2veya(x1,y1,x2,y2)