魔方的原理是什么？
（小石頭，站在偏數學的角度，來回答這個問題。簡單一句話，魔方的原理就是：魔方群在狀態集上的作用，具體回答如下：）
魔方群
整體來看，魔方（Rubik's cube）是一個立方體，一共有六個面 （surface），我們分別用 U（up 上）、D（down 下）、F （front 前）、B（back 后）、L（left 左）、R（right 右）來標識，不妨規定：U 對應 黃（yellow）、D 對應 白（white）、F 對應 藍（blue）、B 對應 綠（green）、L 對應 橙（orange）、R 對應 紅（red）。
令，M = {U, D, F, B, L, R}，當 任意面 f ∈ M 朝向我們時，對 f 面 順時針 旋轉 90°， 被定義為 魔方的 基本操作（base operation），同樣用 f 面 的 面標識 來表示 這種基本操作。所以 M 也代表 魔方的全部基本操作。
對于，任意 基本操作 g, h ∈ M，gh 稱為 g 和 h 的 復合（compose）， 表示 先 g 操作 再 h 操作 的復合操作。可以驗證，復合滿足結合律， 這樣以來，以 M 為生成元 在復合操作下會生成一個群 G = (M)，稱為 魔方群（Rubik‘s cube group)。其中，G 的 幺元，記為 1， 表示 沒有進行任何操作的操作。
什么是群？
群就是定義了一種運算 的集合 ，其 滿足：
集合對運算封閉，即，對于任意 都有 ( 注意：和乘法運算類似，習慣省略不寫 ) ；
運算有分配律，即， 對于任意 都有 ；
有幺元，即，存在 使得 對于 任意 都有 ；
有逆元，即，對于任意 都存在 的逆元 使得 。
什么是 M 生成的群？
數學上定義：包括 M 中元素的 最小的群，為M生成的群，記為 (M)。實際上，可以 對 M 中任意操作 g 和 h 不斷的 進行 復合運算，如果得到的新復合操作 gh 不在 M 中，就 gh 添加到 M 里，直到 M 不再增加，這樣就得到了 (M)。
同一基本操作 g， 連續四次 復合 就是 對 g 面 順時針 旋轉 360°，這相當于 沒有操作，即，
gggg = 1
從而有：
gg3 = 1
也就是說 g3 就是 g 的逆元 g?1 ，相當于 對 g 面 逆時針 旋轉 90°。
另外，由 gggg = 1 還可以得到：
g2g2 = 1
這說明 連續兩次 復合 g2 的逆元 就是自己，即，順時針 旋轉 180° 相當于 逆時針 旋轉 180° 。
魔方狀態
三階魔方被細分為 3 × 3 × 3 = 27 個 立方小塊（cubie）。其中，位于 中間核心的 那個 小塊 不會受到 魔方操作 的影響到，而對于 每個 面中心的 那個 小塊 魔方操作 同樣無法改變它的位置，因此 魔方操作 所能 影響到的 小塊 為 27 - (1 + 6) = 20 個。
這 20 個 受 魔方操作 作用的 小塊，又分為 兩類：
位于魔方 8 個角 處的 角（corner）塊，它們有3個有效 小面（facet）；
位于魔方 12 個棱 處的 棱（edge）塊，它們有2個有效 小面；
由于，每個面的 中心塊 保持位置不變，因此對于打亂的魔方，可以依照 中心塊 來 確定 魔方的各個面 方向。魔方在初始（或 還原）狀態下，角塊 和 棱塊 的每個 小面 和 該小面 所在面 的 中心小塊 顏色保持一致。
我們用 角塊（或 棱塊） 的各小面 顏色所對應的 標識 的小寫字母 的組合來標識 角塊（或 棱塊）：
對于 角塊，三個小面 x, y, z，有 6 種排列方式，這里 使用 從 u 或 d 開始 的 順時針 排列方式，即，角塊標識 xyz 保證 x = u/d 并且 x →y → z 是順時針；
對于 棱塊，二個小面 x, y, 有 2 種 排列方式，這里 使用 從 u 或 d（f 或 b） 開始 的 排列方式，即，棱塊標識 xy 保證 x = u/d/f/b；
根據上面的規則，八個角塊分別表示為：ufl, urf, ubr, ulb; dbl, dlf, dfr, drb; 十二個棱塊分別表示為：ub, ur, uf, ul; bl, br, fr, fl; db, dr, df, dl
注意：六個中心塊 分別表示為：u, d, f, b, l, r，核心塊 一般用 o 表示 。
更進一步，對于角塊 xyz，我們用 xyz 表示 x 小面，yzx 表示 y 小面，zxy 表示 z 小面，對于棱塊 xy ，我們用 xy 表示 x 小面，用 yx 表示 y 小面，于是，我們就得到了 帶有標注 的 8 × 3 + 12 × 2 = 48 個 小面。將，全體小面記為 T，則 任意 操作 g ∈ G 就變成了 T 上的 一種 置換（位置變換）。以 F 操作 為例，
觀察發現， 小面 fur 經過 F 操作 置換 為 小面 flu，即，F(fur) = flu，另有 F(flu) = fdl、F(fdl) = frd、F(frd) = flu，于是 在 F 操作下，以上 4 個置換 形成了 一個 置換圈：
我們稱其為 輪換（cycle），記為 (fur flu fdl frd) 。
參與輪換的 小面 可以是任意多個，值得注意的是：任何一個小面 a 的 輪換 (a) 相當于 不做 置換，有, 1 = () = (a) 。
當然，實際上 F 操作 包含 多個 輪換，將這些輪換 以復合的方式，聚合在一起，就是定義了一個 完整 F 操作：
F = (fur flu fdl frd) (fu fl fd fr)(rfu ufl lfd dfr)(rf uf lf df)(rdf urf luf dlf)
同理，我們可以將 其它魔方操作 定義為 輪換 的復合。
注意：為了方便，我們也可以用 1- 48 的 正整數，來替代 上面 S 中 對小面 的編碼。
T 上的所有 置換函數，在函數復合下，組成 置換群 S??。但是，因為 角塊的面永遠置換不到棱塊的面，所以 G 僅僅是 S?? 的子群。
用離散的小面來記錄魔方的狀態過于粗獷，重新審視魔方，我們會得到如下結果：
每個立方塊都是一個整體，在任何魔方的操作下，組成它的小面不會分離；
每個立方塊，有兩種狀態信息：位置 和 方向；
角塊 和 棱塊 在 魔法操作下 相互獨立，即，角塊 永遠不可能 轉到 棱塊 上，反之亦然。
基于，以上分析，我們首先， 分別 對 角塊 和 棱塊 進行定位（location）：
角塊：ufl = 1, urf = 2, ubr = 3, ulb = 4; dbl = 5, dlf = 6, dfr = 7, drb = 8;
棱塊：ub = 1, ur = 2, uf = 3, ul = 4; bl = 5, br = 6, fr = 7, fl = 8; db = 9, dr = 10, df = 11, dl = 12;
令 C = {1, 2, 3, 4, 5, 6, 7, 8}， 這里包含 所有 角塊的位置信息，可以很容易將 基本操作 對 角塊位置的 改變寫成輪換形式：
U = (1 2 3 4),
D = (5 8 7 6),
F = (1 6 7 2),
B = (3 8 5 4),
L = (1 4 5 6),
R = (2 7 8 3)
顯然，G 作用在 C 上 是 置換群 S? 的子群。
同理，令 E = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}，基本操作對于 棱塊 位置的改變寫成輪換形式為：
U = (1 4 3 2),
D = (9 10 11 12),
F = (3 8 11 7),
B = (1 6 9 5),
L = (4 5 12 8),
R = (2 7 10 6)
同樣，G 作用在 E 上 是 置換群 S?? 的子群。
然后，我們分別對 角塊 和 棱塊 進行定向（orientation）：
角塊：u/d 為定向面，xyz = 012；
棱塊：u/d/f/b 為定向面，xy = 01；
對于保持 定向 信息，我們只需要定義，定位位置 當前 立方塊 的 定向面 對應 的 編號就可以了。而對于 基本操作，對 定向的 改變，我們也只需要 記錄，原始狀態下，經過 基本操作后，各個 定位位置，的 定向面 對應 的 編號就可以了。如果，原始狀態下，即， 定向面的編號為 0，經過某操作，到新位置后，定向面編號為 n，則 原來 定向面的編號為 m，經同樣操作，到新位置后，定向面編號就是 (n + m) mod k，對于角塊 k = 3，對于 棱塊 k = 2。0- 不旋轉，1-逆時針旋轉，2-順時針旋轉。
令，V = (0, 0, 0, 0, 0, 0, 0, 0) 表示 角塊的所有定向，則 基本操作為對角塊定向的改變為：
U = (0, 0, 0, 0, 0, 0, 0, 0),
D = (0, 0, 0, 0, 0, 0, 0, 0),
F = (1, 2, 0, 0, 0, 2, 1, 0),
B = (0, 0, 1, 2, 1, 0, 0, 2),
L = (2, 0, 0, 1, 2, 1, 0, 0),
R = (0, 1, 2, 0, 0, 0, 2, 1)
對于每一位來說都是 Z? ，總共 8 個 Z? 就是 Z?? ，但是 考慮 在 到 7 個 角塊固定的情況下，我們無法 單獨 旋轉 剩下的那個，因此 G 在 V 上的作用 實際上 是 Z??。
令，W = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) 表示 棱塊的所有定向，則 基本操作為對棱塊定向的改變為：
U = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
D = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
F = (0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0),
B = (1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0),
L = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
R = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
同理， G 在 W 上的作用 是 Z?11。
當以上編號混合在一起使用時，為了區分，分別用 c、e、v、w 作為 角塊定位、棱塊定位、角塊定向、棱塊定向 編號的前綴，并將編號寫成下標。例如：
F = (c? c? c? c?) (e? e? e?? e?) (v?, v?, v?, v?, v?, v?, v?, v?) (w?, w?, w?, w?, w?, w?, w?, w?, w?, w?, w?, w?)
輔助工具
在進行下一步分析之前，我們先編寫一點 JavaScript 代碼，以幫助我們，對 G 中的 操作進行復合。
魔方狀態（state）的 格式為：
state：[[角塊定位], [棱塊定位], [角塊定向], 棱塊定向]
聲明 魔方初始狀態 s? 如下：
魔方操作（operation）的 格式為：
[[[角塊輪換], ...], [[棱塊輪換], ...], [角塊旋轉], [棱塊旋轉]]
基本操作聲明如下：
聲明，在給定狀態上執行魔方操作的函數：
聲明，從給定狀態中分析出魔方操作的函數：
定義 復合 函數：
為了輸出簡潔，當所有角塊（或，棱塊）不發生旋轉 時，用一對空括號表示。
最后，我們對基本操作進行必要的擴展：
換位子 和 共軛
對于 任意兩個 魔方操作 g,h ∈ G，如果，g 和 h 的復合 滿足交換律，則：
gh = hg
等式兩邊右乘 g?1h?1，有：
ghg?1h?1 = hgg?1h?1 = h1h?1 = hh?1 = 1
如果 不滿足交換律，則：
ghg?1h?1 ≠ 1
令，[g, h] = ghg?1h?1，稱其為 換位子（commutator）。
一般來說，魔方相對面 ，如： F 和 B，U 和 D，L 和 R 之間是可以交換的，即，
[F, B] = [U, D] = [L, R] = 1
所有，換位子 之間是可以交換的，即：
[[g?, h?] [g?, h?]] = 1
關于，換位子有 性質1：如果 g 和 h 兩種操作，只 共同影響 一個 小塊 k，其中 g 為 n → k，h 為 m → k，則有 [g, h] = (k, n, m)，[h, g] = (k, m, n)。
例如，若 g = (c? c? c?), h = (c?, c? c?)，則 k = c?, n = c?, m = c?，于是有：
即，[g, h] = (c? c? c?)，[h, g] = (c? c? c?)。
性質1推論：如果 g 和 h 兩種操作，共同影響 的小塊，剛好 在 g 和 h 中 分別 形成 輪換 σ 和 τ，則有 [g, h] = [σ, τ]。
例如：若 g = (c? c? c? c?)(c? c?), h = (c? c? c? c?)(c? c?)，則 它們的共同影響小塊 c?、c?、c?、c?，分別 在 g 和 h 中，組成輪轉 (c? c? c? c?) 和 (c? c? c? c?)，于是有：
即，[g, h] = [(c? c? c? c?), (c? c? c? c?)]。
魔方群中還有另外一種 稱為 共軛（conjugate）的復合方式：對于 任何操作 g,h ∈ G，稱 ghg?1 為 h 關于 g 的共軛。
共軛具有 性質2：如果 h = (a b c) 而 g 將 A, B, C 分別映射到 a, b, c，則有 ghg?1 = (A B C)。
例如：若 h = (c? c? c?), g = (c? c?)(c? c?)(c? c?)，則有：
即，ghg?1 = (c? c? c?)。
魔方公式
好了！現在利用上面的知識，就可以開始構造魔方公式了。
尋找角塊的換位公式
我們發現 B?1 關于 R?1 的 共軛 R?1B?1(R?1)?1 = R?1B?1R：
和 F2：
僅有 c? 共同影響，于是它們滿足 性質1，有：
即，[R?1B?1R, F2] = R?1B?1R F2 (R?1B?1R)?1 (F2)?1 = R?1B?1R F2 R?1B?1R F2 = (c1, c7, c8)。
注意：因為 (ab)(b?1a?1) = abb?1a?1 = a1a?1 = aa?1 = 1，所以 (ab)?1 = b?1a?1。
這里 c?, c?, c? 不共面，考慮 R2 :
剛好 將 1 ? 1, 2 ? 8, 3 ? 7，于是根據 性質2，有：
開頭的 RR RRR = R ，于是最終得到 公式C：
即，
R2[R?1B?1R, F2]R?2 = RB?1RF2R?1BRF2R2 = (c? c? c?)
尋找棱塊的換位公式
我們定義一種新的操作 M：面對 F 面，順指針旋轉 F 和 B 面之間那個中間的面M。M 操作 只改變棱塊：
我們發現 M?1（或 M）與 U2：
共同影響 e?，因此 根據性質1，[M?1, U2] 構成三輪換：
即，[M?1, U2] = M?1U2MU2 = (e? e? e??)。
其實，M?1 就相當于 FB?1 的復合，只不過，在執行 M?1 后，還做了 R 面朝向了 U 的動作。
這時 執行 U2 相當于 執行 R2，于是翻譯為 基本操作 [M?1, U2] = FB?1R2BF?1U2，驗證：
最后， 根據 性質2，利用 R2U 將 這個 三輪換，換到同一個面上：
倒數第2， 3 項合并后，就得到了 公式D：
R2U[M?1, U2]U?1R2 = R2UFB?1R2BF?1UR2 = (e? e? e?)
尋找角塊的旋轉公式
觀察 D2 關于 RF?1 的共軛 RF?1D2FR?1：
與 U2：
它們，有共同的輪轉 (c? c?)，于是根據 性質1推論，有：
[U2, RF?1D2FR?1] = [(c? c?), (c? c?)] = (c? c?)(c? c?)(c? c?)(c? c?) = (c? c?)1(c? c?) = (c? c?)(c? c?) = 1
這樣以來，[U2, RF?1D2FR?1] 就沒有了位置變換，僅僅剩下的就是旋轉：
于是，我們就得到 公式 E：
[U2, RF?1D2FR?1] = U2RF?1D2FR?1U2RF?1D2FR?1 = (v?, v?, v?, v?, v?, v?, v?, v?);
公式 E 分別 對 c? 和 c? 進行 逆時針 和 順時針 旋轉。
尋找棱塊的旋轉公式
M 和 U 分別執行4次會恢復，那么 MU 執行四次，即，(MU)? 是什么呢？
我們神奇的發現：
(MU)? = F?1BLF?1BDF?1BRF?1BU = (w?, w?, w?, w?, w?, w?, w?, w?, w?, w?, w?, w?)
即，(MU)? 只對 e?, e?, e?0, e?? 旋轉；
同樣，(MU?1)? ：
(MU?1)? = F?1BL?1F?1BD?1F?1BR?1F?1BU?1 = (w?, w?, w?, w?, w?, w?, w?, w?, w?, w?, w?)
即，(MU?1)? 只對 e?, e3, e?0, e?? 旋轉；
因為 棱塊旋轉 2 次就等于沒有旋轉，于是 (MU)? 和 (MU?1)? 的復合 結果 只對 e? 和 e? 進行旋轉，這就是 公式F：
(MU)?(MU?1)? = (w?,w?, w?, w?, w?, w?, w?, w?, w?, w?, w?)
可以驗證：
暴力搜索
兩輪換 稱為 對換，在魔方群中 單獨的 對換操作，是不可能的 因此 三輪換，成立 公式構造的 關鍵，除了上面利用 性質1 來 找尋 三輪換 的 方法為，我們還可以用計算機，進行暴力搜索。例如：在 2 個 R，3 個 R?1， 3 個 U, 2 個 U?1 的全排列中，進行三輪換搜索：
我們得到：
即，R?1U?1RURURU?1R?1U?1 = (e? e? e??)。然后 根據 性質2，利用 R2 將 這個 三輪換，換到同一個面上：
同樣，將開頭的 5 個 R 合并，就得到 和 公式D 類似的公式：
RU?1RURURU?1R?1U?1R2 = (e? e? e?)
對于旋轉來說，以上的分析，最少只能的道 兩個 角塊（或 棱塊）的旋轉，我們無法做到 僅僅旋轉 一個角塊（或 棱塊）。
上面，給定的公式都保證 角塊（或 棱塊）的旋轉 時，所有小塊位置不變，但 實際上，不一定需要這么嚴格，我們可以允許 與旋轉小塊同處一個面 內 小塊的位置變換。通過暴力搜索，我們得到了公式B：
即，
RUR?1URU2R?1 = (c? c?)(c? c?)(e? e? e?)(v?, v?, v?, v?, v?, v?, v?, v?);
以及，公式A：
即，
FRUR?1U?1F?1 = (c? c?)(c? c?)(e? e? e?)(v?, v?, v?, v?, v?, v?, v?, v?)(w?, w?, w?, w?, w?, w?, w?, w?, w?, w?, w?, w?);
公式 AB 都是 只 改變 頂層 位置的 操作。
其實，公式A就是 F[R, U]F?1，其中 [R, U]：
[R, U] 的功效是 (e? e? e?) ，即，將 頂層棱塊 e? e? 和 中層 棱塊 e? 輪換，但副作用 (c? c?) 變動了 底層。不過幸運的是，我們找到了 [F?1, U?1]：
[ F?1, U?1] 的功效 和 [R, U] 類似，而其副作也是 (c? c?)。因為 (c? c?)(c? c?) = 1，所以 [U?1, F?1] 的 剛好可以抵消 [R, U] 的副作用。于是，我們就得到了 公式A的附帶公式：
[R, U] [ F?1, U?1] 和 [ F?1, U?1] [R, U]
功效分別是 (e? e? e? e? e?) 和 (e? e? e? e? e?)，即，將頂層的 四個棱塊 與 中層 的 棱塊 e? 輪轉。
在魔方數學原理的指導下，通過這種計算機暴力搜索的方式，我們還可以找到很多有用的公式，目前緊緊OLL公式就有 57 個，而更多的復雜公式幾百上千。
眾所周知的 ”七步公式還原法“（層先法） 就包括了從這些公式中選出來的 一組基礎公式（包括上面提到的 公式ABCD）。（七步公式還原法，已經有條友在回答中詳細介紹過了，我這里就不累述了。）
不知不覺，已經寫了 5千余字了。關于魔法群還有很多更深入的內容，例如：上帝數 等，由于篇幅有限，這里不能一一展開，以后有機會再說。
（小石頭，數學水平有限，出錯在所難免，希望各位老師和同學批評指正。）
（補充 2019/10/30）
我將輔助工具的代碼放在這里，以便想要自己試驗的條友復制粘貼。
運行環境：chrome 瀏覽器；
文件名：rc.html，包含代碼：
<script>const s0 = [[1, 2, 3, 4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]; const U = [[[1, 2, 3, 4]],[[1, 4, 3, 2]], [0, 0, 0, 0, 0, 0, 0, 0],[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]];const D = [[[5, 8, 7, 6]],[[9, 10, 11, 12]],[0, 0, 0, 0, 0, 0, 0, 0],[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]];const F = [[[1, 6, 7, 2]],[[3, 8, 11, 7]], [1, 2, 0, 0, 0, 2, 1, 0],[0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0]]; const B = [[[3, 8, 5, 4]],[[1, 6, 9, 5]], [0, 0, 1, 2, 1, 0, 0, 2],[1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0]];const L = [[[1, 4, 5, 6]],[[4, 5, 12, 8]], [2, 0, 0, 1, 2, 1, 0, 0],[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]];const R = [[[2, 7, 8, 3]],[[2, 7, 10, 6]], [0, 1, 2, 0, 0, 0, 2, 1],[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]];function perform(state, ... operations) { for(var g of operations) { var newstate = [g[0].reduce((l, c) => permute(l, c), state[0]), g[1].reduce((l, c) => permute(l, c), state[1])]; newstate[2] = turn(state[0], state[2], newstate[0], g[2], 3); newstate[3] = turn(state[1], state[3], newstate[1], g[3], 2); state = newstate; } return state;}function permute(location, cycle) { var newlocation = Array.from(location); for(var i = 0; i < cycle.length - 1; i++) { newlocation[cycle[i] - 1] = newlocation[cycle[i+1] - 1]; } newlocation[cycle[cycle.length - 1] - 1] = location[cycle[0] - 1]; return newlocation ;}function turn(oldlocation, oldorientation, newlocation, spin, mod) { var neworientation = []; for (var i = 0; i < newlocation.length; i++) { var j = oldlocation.indexOf(newlocation[i]); neworientation[i] = (oldorientation[j] + spin[i]) % mod; } return neworientation;}function parse(state) { return [parse_cycle(state[0]), parse_cycle(state[1]), Array.from(state[2]), Array.from(state[3]) ];}function parse_cycle(location) { var flags = [], cycles = []; for (var i = 0; i < location.length; i ++) { if (i + 1 != location[i] && !flags[i]) { var cycle = [i + 1, location[i]], j = location[i] - 1; while(true) { flags[j] = 1; if (location[j] == i + 1) break; cycle.push(location[j]); j = location[j] - 1; } cycles.push(cycle); } } return cycles;}function compose(... operations) { return parse(perform(s0, ... operations));}const str = arr => arr.reduce((s, x) => s + (x[0] instanceof Array ? '[(' + x.map(y => y.join(' ')).join(')(') + ')]' : (x.length == 0 ? '[]' : '(' + x.join() + ')')), '') .replace('(0,0,0,0,0,0,0,0)', '()') .replace('(0,0,0,0,0,0,0,0,0,0,0,0)', '()');const c = (... ops) => str(compose(... ops)); const UU = compose(U, U), UUU = compose(U, U, U);const DD = compose(D, D), DDD = compose(D, D, D);const FF = compose(F, F), FFF = compose(F, F, F);const BB = compose(B, B), BBB = compose(B, B, B);const LL = compose(L, L), LLL = compose(L, L, L);const RR = compose(R, R), RRR = compose(R, R, R);const cycle = (... x) => [[x], [], s0[2], s0[3]];const M = [[],[[2,4,12,10]],[0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1]];const MMM = compose(M, M, M);function perm(arr, callback, index){ var swap = (a, i, j, t) => (t = a[i], a[i] = a[j], a[j] = t); index = index || 0; if (index < arr.length) { for (var j = index; j < arr.length; j++) { swap(arr, index, j); if (perm(arr, callback, index + 1)) return true; swap(arr, index, j); } } else { return callback(arr); }}</script>文件名：rc2.html，包含代碼：
<script>function perm(arr, callback, index){ var swap = (a, i, j, t) => (t = a[i], a[i] = a[j], a[j] = t); index = index || 0; if (index < arr.length) { for (var j = index; j < arr.length; j++) { swap(arr, index, j); if (perm(arr, callback, index + 1)) return true; swap(arr, index, j); } } else { return callback(arr); }}R._tag = "R"; RRR._tag = "R?1"; U._tag = "U", UUU._tag = "U?1";perm([RRR, UUU, R, U, RRR, UUU, R, U, R, UUU], x => { var g = compose(... x); console.log("+"); if (g[0].length == 0 && g[1].length == 1 && g[1][0].length == 3 && g[2].toString() == s0[2].toString() && g[3].toString() == s0[3].toString()) { console.log(x.reduce((y, z) => y + z._tag, "")); return true; }});</script>