กลุ่มไดฮีดรัล$D_4$เป็นกลุ่มสมมาตรของจตุรัสนั่นคือการเคลื่อนไหวที่เปลี่ยนสแควร์เป็นตัวของมันเองผ่านการหมุนและการสะท้อนกลับ ประกอบด้วย 8 องค์ประกอบ: การหมุน 0, 90, 180 และ 270 องศาและการสะท้อนกลับในแนวนอนแนวตั้งและแกนแนวทแยงสองแกน

ภาพทั้งหมดมาจากหน้าน่ารักนี้โดย Larry Riddle

ความท้าทายนี้เกี่ยวกับการเขียนการเคลื่อนไหวเหล่านี้: เมื่อได้รับการเคลื่อนไหวสองครั้งแล้วให้ส่งออกท่าที่เทียบเท่ากับการทำสิ่งต่อไปนี้ ตัวอย่างเช่นการย้าย 7 ตามด้วยการย้าย 4 จะเหมือนกับการย้าย 5

โปรดทราบว่าการสลับคำสั่งเพื่อย้าย 4 จากนั้นย้าย 7 จะสร้างการย้าย 6 แทน

ผลสรุปได้ดังนี้; นี้เป็นตารางเคย์ลีของกลุ่ม$D_4$ 4 ตัวอย่างเช่นอินพุต$7, 4$ควรผลิตออก5$5$

$$\begin{array}{*{20}{c}} {} & {\begin{array}{*{20}{c}} 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 \\ \end{array} } \\ {\begin{array}{*{20}{c}} 1 \\ 2 \\ 3 \\ 4 \\ 5 \\ 6 \\ 7 \\ 8 \\ \end{array} } & {\boxed{\begin{array}{*{20}{c}} 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 \\ 2 & 3 & 4 & 1 & 8 & 7 & 5 & 6\\ 3 & 4 & 1 & 2 & 6 & 5 & 8 & 7\\ 4 & 1 & 2 & 3 & 7 & 8 & 6 & 5\\ 5 & 7 & 6 & 8 & 1 & 3 & 2 & 4\\ 6 & 8 & 5 & 7 & 3 & 1 & 4 & 2\\ 7 & 6 & 8 & 5 & 4 & 2 & 1 & 3\\ 8 & 5 & 7 & 6 & 2 & 4 & 3 & 1\\ \end{array} }} \\ \end{array}$$

ท้าทาย

เป้าหมายของคุณคือการใช้การดำเนินการนี้ในไม่กี่ไบต์เท่าที่จะทำได้ แต่นอกเหนือจากรหัสแล้วคุณยังเลือกป้ายกำกับที่แสดงการเคลื่อนไหว 1 ถึง 8 ป้ายกำกับต้องมี8 ตัวเลขที่แตกต่างกันตั้งแต่ 0 ถึง 255หรือ 8 หนึ่ง - อักขระไบต์จุดรหัสของพวกเขาแทน

รหัสของคุณจะได้รับป้ายกำกับสองรายการจาก 8 รายการที่คุณเลือกและต้องส่งออกป้ายกำกับที่สอดคล้องกับองค์ประกอบในกลุ่ม dihedral $D_4$ 4

ตัวอย่าง

สมมติว่าคุณเลือกอักขระ C, O, M, P, U, T, E, R สำหรับการเลื่อน 1 ถึง 8 ตามลำดับ จากนั้นรหัสของคุณควรใช้ตารางนี้

$$\begin{array}{*{20}{c}} {} & {\begin{array}{*{20}{c}} \, C \, & \, O \, & M \, & P \, & U \, & \, T \, & \, E \, & R \, \\ \end{array} } \\ {\begin{array}{*{20}{c}} C \\ O \\ M \\ P \\ U \\ T \\ E \\ R \\ \end{array} } & {\boxed{\begin{array}{*{20}{c}} C & O & M & P & U & T & E & R \\ O & M & P & C & R & E & U & T\\ M & P & C & O & T & U & R & E\\ P & C & O & M & E & R & T & U\\ U & E & T & R & C & M & O & P\\ T & R & U & E & M & C & P & O\\ E & T & R & U & P & O & C & M\\ R & U & E & T & O & P & M & C\\ \end{array} }} \\ \end{array}$$

รับอินพุต E และ P คุณควรเอาต์พุต U อินพุตของคุณจะเป็นสองตัวอักษร C, O, M, P, U, T, E, R และเอาต์พุตของคุณควรเป็นหนึ่งในตัวอักษรเหล่านี้เสมอ

ตารางข้อความสำหรับการคัดลอก

1 2 3 4 5 6 7 8
2 3 4 1 8 7 5 6
3 4 1 2 6 5 8 7
4 1 2 3 7 8 6 5
5 7 6 8 1 3 2 4
6 8 5 7 3 1 4 2
7 6 8 5 4 2 1 3
8 5 7 6 2 4 3 1

ทับทิมขนาด 18 ไบต์

->a,b{a+b*~0**a&7}

Ungolfed

->a,b{ (a+b*(-1)**a) % 8}  
# for operator precedence reasons, 
#-1 is represented as ~0 in the golfed version 

ลองออนไลน์!

ใช้หมายเลขการเข้ารหัสต่อไปนี้ 0 ถึง 7

ในการสั่งซื้อรหัสพื้นเมือง:

Native     Effect                    Codes per
Code                                 Question
0          rotate 0 anticlockwise    1C
1 /        flip in y=x               7E
2 /|       rotate 90 anticlockwise   2O
3 /|/      flip in x axis            5U
4 /|/|     rotate 180 anticlockwise  3M
5 /|/|/    flip in y=-x              8R
6 /|/|/|   rotate 270 anticlockwise  4P
7 /|/|/|/  flip in y axis            6T

ตามลำดับต่อคำถาม

Native     Effect                    Codes per
Code                                 Question
0          rotate 0 anticlockwise    1C
2 /|       rotate 90 anticlockwise   2O
4 /|/|     rotate 180 anticlockwise  3M
6 /|/|/|   rotate 270 anticlockwise  4P
3 /|/      flip in x axis            5U
7 /|/|/|/  flip in y axis            6T
1 /        flip in y=x               7E
5 /|/|/    flip in y=-x              8R

คำอธิบาย

/แสดงถึงการพลิกในบรรทัดy=xและ|แสดงถึงการพลิกในแกน y

เป็นไปได้ที่จะสร้างสมมาตรใด ๆ ของกลุ่ม D4 โดยสลับกันในสองบรรทัดนี้ตัวอย่างเช่น/ตามด้วยการ|ให้/|ซึ่งเป็นการหมุน 90 องศาทวนเข็มนาฬิกา

จำนวนการโยนติดต่อกันทั้งหมดช่วยให้การแทนเลขคณิตสะดวกยิ่งขึ้น

หากการเลื่อนครั้งแรกเป็นการหมุนเราสามารถเพิ่มจำนวนการพลิกได้:

Rotate 90 degrees   +  Rotate 180 degrees = Rotate 270 degrees
/|                     /|/|                 /|/|/|

Rotate 90 degress   +  Flip in y=x        = Flip in x axis   
/|                    /                     /|/

หากการเคลื่อนที่ครั้งแรกเป็นการสะท้อนเราจะพบว่าเรามีการสะท้อน/และ|สัญลักษณ์ที่เหมือนกันอยู่ติดกัน เนื่องจากการสะท้อนกลับเป็นสิ่งที่ตรงกันข้ามเราสามารถยกเลิกการพลิกเหล่านี้ทีละตัว ดังนั้นเราต้องลบการเคลื่อนที่หนึ่งครั้งจากอีกอันหนึ่ง

Flip in x axis     +  Flip in y=x        = Rotate 90 degrees
/|/                   /                    /|/ / (cancels to) /|

Flip in x axis     +  Rotate 90 degrees  = Flip in y=x
/|/                   /|                   /|/ /| (cancels to ) / 

ภาษา Wolfram (Mathematica) , 31 ไบต์

ใช้จำนวนเต็ม$0, 5, 2, 7, 1, 3, 6, 4$เป็นป้ายกำกับ

BitXor[##,2Mod[#,2]⌊#2/4⌋]&

ลองออนไลน์!

คำอธิบาย:

กลุ่ม Dihedral $D_4$ isomorphic กับกลุ่มเมทริกซ์หน่วยของรูปสามเหลี่ยมที่มีองศาเหนือสนาม$\mathbb{F}_2$ :

$$D_4 \cong U(3,2) := \left\{\begin{pmatrix} 1 & a & b \\ 0 & 1 & c \\ 0 & 0 & 1 \end{pmatrix} \mid a,b,c \in \mathbb{F}_2\right\}.$$

และเรามี

$$\begin{pmatrix} 1 & a_1 & b_1 \\ 0 & 1 & c_1 \\ 0 & 0 & 1 \end{pmatrix} \cdot \begin{pmatrix} 1 & a_2 & b_2 \\ 0 & 1 & c_2 \\ 0 & 0 & 1 \end{pmatrix} = \begin{pmatrix} 1 & a_1+a_2 & b_1+b_2+a_1c_2 \\ 0 & 1 & c_1+c_2 \\ 0 & 0 & 1 \end{pmatrix},$$

ซึ่งสามารถเขียนได้ง่ายในการทำงานระดับบิต

ภาษา Wolfram (Mathematica) , 51 ไบต์

⌊#/4^IntegerDigits[#2,4,4]⌋~Mod~4~FromDigits~4&

ลองออนไลน์!

{228, 57, 78, 147, 27, 177, 198, 108}การใช้ป้ายกำกับ

สิ่งเหล่านี้อยู่{3210, 0321, 1032, 2103, 0123, 2301, 3012, 1230}ในฐาน 4 โชคดีที่ 256 = 4 ^ 4

---

การใช้งานระดับล่างเช่นกัน 51 ไบต์

Sum[4^i⌊#/4^⌊#2/4^i⌋~Mod~4⌋~Mod~4,{i,0,3}]&

ลองออนไลน์!

Python 2 , 22 ไบต์

$0, 6, 1, 7, 2, 3, 5, 4$

lambda a,b:a^b^a/2&b/4

ลองออนไลน์!

Python 2 , 26 23 21 ไบต์

lambda x,y:y+x*7**y&7

ลองออนไลน์! พอร์ตคำตอบของฉันไปยังCayley Table of the Dihedral Group$D_3$. แก้ไข: บันทึกแล้ว 3 ไบต์ขอบคุณ @NieDzejkob บันทึก 2 ไบต์ขอบคุณ @xnor สำหรับการแนะนำตัวดำเนินการand(มากกว่าxnor) ใช้การแม็พต่อไปนี้:

 id | r1 | r2 | r3 | s0 | s1 | s2 | s3 
----+----+----+----+----+----+----+----
 0  | 2  | 4  | 6  | 1  | 3  | 5  | 7  

TI-BASIC, 165 ไบต์

Ans→L₁:{.12345678,.23417865,.34126587,.41238756,.58671342,.67583124,.75862413,.86754231→L₂:For(I,1,8:10fPart(.1int(L₂(I)₁₀^(seq(X,X,1,8:List▶matr(Ans,[B]:If I=1:[B]→[A]:If I-1:augment([A],[B]→[A]:End:[A](L₁(1),L₁(2

Ansป้อนข้อมูลคือรายการของความยาวสองใน
เอาท์พุทเป็นจำนวนที่(row, column)ดัชนีในตาราง

อาจมีวิธีการบีบอัดที่ดีกว่าซึ่งจะช่วยประหยัดไบต์ แต่ฉันจะต้องดูว่า

ตัวอย่าง:

{1,2
           {1 2}
prgmCDGF1B
               2
{7,4
           {7 4}
prgmCDGF1B
               5

คำอธิบาย:
(มีการเพิ่มบรรทัดใหม่เพื่อให้สามารถอ่านได้)

Ans→L₁                              ;store the input list into L₁
{.123456 ... →L₂                    ;store the compressed matrix into L₂
                                    ; (line shortened for brevity)
For(I,1,8                           ;loop 8 times
10fPart(.1int(L₂(I)₁₀^(seq(X,X,1,8  ;decompress the "I"-th column of the matrix
List▶matr(Ans,[B]                   ;convert the resulting list into a matrix column and
                                    ; then store it into the "[B]" matrix variable
If I=1                              ;if the loop has just started...
[B]→[A]                             ;then store this column into "[A]", another matrix
                                    ; variable
If I-1                              ;otherwise...
augment([A],[B]→[A]                 ;append this column onto "[A]"
End
[A](L₁(1),L₁(2                      ;get the index and keep it in "Ans"
                                    ;implicit print of "Ans"

นี่เป็นวิธีแก้ปัญหา155 ไบต์แต่มันก็แค่เข้ารหัสเมทริกซ์และรับดัชนี
ฉันพบว่ามันน่าเบื่อมากขึ้นดังนั้นฉันจึงไม่ได้ทำให้เป็นทางการของฉัน:

Ans→L₁:[[1,2,3,4,5,6,7,8][2,3,4,1,8,7,5,6][3,4,1,2,6,5,8,7][4,1,2,3,7,8,6,5][5,7,6,8,1,3,2,4][6,8,5,7,3,1,4,2][7,6,8,5,4,2,1,3][8,5,7,6,2,4,3,1:Ans(L₁(1),L₁(2

---

หมายเหตุ: TI-BASIC เป็นภาษาโทเค็น จำนวนตัวอักษรไม่เท่ากับจำนวนไบต์

เยลลี่ขนาด 6 ไบต์

N⁹¡+%8

ลิงก์ dyadic ยอมรับการแปลงแรกทางด้านขวาและการแปลงที่สองทางด้านซ้ายซึ่งให้การแปลงคอมโพสิต

การเปลี่ยนแปลงอยู่ที่ไหน:

as in question:  1    2    3    4    5    6    7    8
transformation: id  90a  180  90c  hor  ver  +ve  -ve
  code's label:  0    2    4    6    1    5    7    3

ลองออนไลน์! ... หรือดูตารางแมปกลับไปยังป้ายในคำถาม

(ข้อโต้แย้งสามารถดำเนินการในลำดับอื่นโดยใช้ 6 byter _+Ḃ?%8)

อย่างไร?

แต่ละฉลากคือความยาวของลำดับการสลับhorและการ+veแปลงซึ่งเทียบเท่ากับการแปลง (เช่น180เทียบเท่าhor, +ve, hor, +ve)

การจัดวางA,Bนั้นเทียบเท่ากับการต่อกันของสองลำดับที่เท่ากันและช่วยให้การลบง่ายขึ้นหรือการบวกโมดูโลที่แปด ...

ใช้7, 4ตัวอย่างของคำถามที่เรามี+ve, 90cคือ:
hor, +ve, hor, +ve, hor, +ve, hor , hor, +ve, hor, +ve, hor, +ve

... แต่เนื่องจากhor, horเป็นidเรามี:
hor, +ve, hor, +ve, hor, +ve , +ve, hor, +ve, hor, +ve

... และตั้งแต่+ve, +veเป็นidเรามี:
hor, +ve, hor, +ve, hor , hor, +ve, hor, +ve

... และเราสามารถยกเลิกการจองเหล่านี้ซ้ำกับ:
hor
.. เทียบเท่ากับการลบความยาว ( 7-6=1)

เมื่อไม่มีการยกเลิกที่เป็นไปได้เราเพียงแค่เพิ่มความยาว (เช่น 90a, 180 $\rightarrow$ 2+4=6 $\rightarrow$ 90c)

สุดท้ายโปรดทราบว่าลำดับความยาวแปดคือidเพื่อให้เราสามารถนำลำดับความยาวผลลัพธ์แบบโมดูโลแปด

N⁹¡+%8 - Link: B, A
  ¡    - repeat (applied to chain's left argument, B)...
 ⁹     - ...times: chain's right argument, A
N      - ...action: negate  ...i.e. B if A is even, otherwise -B
   +   - add (A)
    %8 - modulo eight

---

นอกจากนี้ยังสั้นกว่าการใช้งานนี้ 1 ไบต์โดยใช้ดัชนีการเปลี่ยนแปลงการจัดเรียงพจนานุกรม:

œ?@ƒ4Œ¿

... การยอมรับลิงก์แบบ monadic [first, second]โดยมีป้ายกำกับ:

as in question:  1    2    3    4    5    6    7    8
transformation: id  90a  180  90c  hor  ver  +ve  -ve
  code's label:  1   10   17   19   24    8   15    6

JavaScript (Node.js) , 22 17 ไบต์

(x,y)=>y+x*7**y&7

ลองออนไลน์! พอร์ตคำตอบของฉันไปยังCayley Table of the Dihedral Group$D_3$แต่ใช้คำแนะนำในคำตอบของ Python ใช้การแม็พต่อไปนี้:

 id | r1 | r2 | r3 | s0 | s1 | s2 | s3 
----+----+----+----+----+----+----+----
 0  | 2  | 4  | 6  | 1  | 3  | 5  | 7  

JavaScript รุ่นที่เก่ากว่าสามารถรองรับได้หลายวิธีสำหรับ 22 ไบต์:

(x,y)=>(y&1?y-x:y+x)&7
(x,y)=>y-x*(y&1||-1)&7
(x,y)=>y+x*(y<<31|1)&7

สนิม 16 ไบต์

|a,b|a^b^a/2&b/4

ลองออนไลน์!

คำตอบ Python ของพอร์ตของ alephalpha แต่สั้นกว่า

Elm , 42 ไบต์ 19 ไบต์

\a b->and 7<|b+a*7^b

พอร์ตของเวอร์ชัน NeodeของNode.js

ลองออนไลน์

รุ่นก่อนหน้า:

\a b->and 7<|if and 1 a>0 then a-b else a+b

Python, 82 71 ไบต์

0-7

-11 ไบต์ขอบคุณ ASCII-only

lambda a,b:int("27pwpxvfcobhkyqu1wrun3nu1fih0x8svriq0",36)>>3*(a*8+b)&7

TIO

สกาล่า , 161 ไบต์

เลือกคอมพิวเตอร์เป็นป้ายกำกับ

val m="0123456712307645230154763012675446570213574620316574310274651320"
val s="COMPUTER"
val l=s.zipWithIndex.toMap
def f(a: Char, b: Char)=s(m(l(a)*8+l(b))-48)

ลองออนไลน์!

สกาล่า , 70 ไบต์

เลือก 0-7 จำนวนเต็มเนทีฟเป็นป้ายกำกับ

บีบอัดเมทริกซ์เป็นสตริง ASCII ขนาด 32 ไบต์แต่ละคู่ของตัวเลข n0, n1 เป็น 1 ตัวอักษร c = n0 + 8 * n1 + 49 เริ่มต้นจาก 49 ถึงเราไม่มี \ ในสตริงที่เข้ารหัส

(a:Int,b:Int)=>"9K]oB4h]K9Vh4BoVenAJne3<_X<AX_J3"(a*4+b/2)-49>>b%2*3&7

ลองออนไลน์!

C # (Visual C # Interactive Compiler)ขนาด 17 ไบต์

a=>b=>a^b^a/2&b/4

คำตอบ Python ของพอร์ตของ alpehalpha

ลองออนไลน์!

Perl 6 , 19 ไบต์

{($^x*7**$^y+$y)%8}

ท่าเรือนีทางออกหลาม

ลองออนไลน์!

ภาษา Wolfram (Mathematica), 7 ไบต์ (การเข้ารหัส UTF-8)

#⊙#2&

ฟังก์ชันบริสุทธิ์รับสองอาร์กิวเมนต์ สัญลักษณ์ที่แสดงที่นี่ในฐานะ⊙เป็นจริง Mathematica ส่วนตัวของ Unicode สัญลักษณ์ F3DE (3 bytes) PermutationProductซึ่งหมายถึงฟังก์ชั่น

Mathematica รู้เกี่ยวกับกลุ่ม dihedral และมันหมายถึงองค์ประกอบของกลุ่มต่าง ๆ เป็นพีชคณิตเขียนโดยใช้Cyclesคำสั่ง ตัวอย่างเช่นการรันคำสั่ง

GroupElements[DihedralGroup[4]]

ผลผลิตผลลัพธ์:

{Cycles[{}], Cycles[{{2, 4}}], Cycles[{{1, 2}, {3, 4}}], 
 Cycles[{{1, 2, 3, 4}}], Cycles[{{1, 3}}], Cycles[{{1, 3}, {2, 4}}], 
 Cycles[{{1, 4, 3, 2}}], Cycles[{{1, 4}, {2, 3}}]}

PermutationProduct เป็นฟังก์ชั่นที่คูณองค์ประกอบกลุ่มเมื่อเขียนในรูปแบบนี้

เนื่องจากเราได้รับอนุญาตให้เลือกป้ายกำกับของเราเองฟังก์ชันนี้จะถือว่าป้ายกำกับเหล่านี้สำหรับองค์ประกอบกลุ่ม การมอบหมายระหว่างป้ายกำกับเหล่านี้และป้ายกำกับในโพสต์ปัญหานั้นได้รับจาก:

Cycles[{}] -> 1
Cycles[{{1, 2, 3, 4}}] -> 2
Cycles[{{1, 3}, {2, 4}}] -> 3
Cycles[{{1, 4, 3, 2}}] -> 4
Cycles[{{2, 4}}] -> 5
Cycles[{{1, 3}}] -> 6
Cycles[{{1, 2}, {3, 4}}] -> 7
Cycles[{{1, 4}, {2, 3}}] -> 8

tl; dr มีตัวใน