Trình tự di chuyển là một chuỗi các bước di chuyển (lượt) trên khối Rubik (đối với ký hiệu nhìn xuống bên dưới). Bên cạnh chuỗi di chuyển trống, còn có nhiều chuỗi di chuyển khác, hoàn toàn không ảnh hưởng đến khối lập phương. Chúng tôi gọi những chuỗi di chuyển trình tự nhận dạng.

Một số trình tự nhận dạng này là rõ ràng để xác định, thích U2 R R' U2hoặc U D2 U' D2. Trong lần đầu tiên, hai động tác ngẫu nhiên được thực hiện U2 Rvà sau đó ngay lập tức hoàn tác R' U2. Cái thứ hai cũng tương tự. Hai bước đầu ngẫu nhiên U D2và sau đó chúng được hoàn tác, nhưng theo thứ tự đảo ngược U' D2. Điều này chỉ hoạt động, bởi vì các Uhiệu ứng di chuyển chỉ các phần của lớp trên và di chuyển D2chỉ có tác dụng các phần của lớp dưới. Bạn có thể thấy một hình dung của hai chuỗi di chuyển này.

Trình tự nhận dạng khác có thể không rõ ràng ở tất cả. Ví dụ trình tự R' U' R' F' U F U' R' F R F' U' R U2 R. Nó khá dài, nhưng cũng không có tác dụng gì cả.

Di chuyển ký hiệu

Một động thái mô tả lần lượt một lớp của một trong sáu mặt của khối lập phương. Một di chuyển bao gồm một chữ cái đại diện cho khuôn mặt theo sau là một hậu tố tùy chọn đại diện cho góc quay.

Các chữ cái và các mặt tương ứng của chúng là U (Lên - mặt hướng lên trên), D (Xuống - mặt hướng xuống dưới), R (Phải - mặt quay sang phải), L (Trái - mặt phải sang trái) , F (Mặt trước - mặt đối diện với bạn) và B (Mặt sau - mặt hướng ra xa bạn).

Nếu không có hậu tố, mặt được quay 90 độ theo chiều kim đồng hồ, hậu tố 'có nghĩa là, mặt được quay 90 độ ngược chiều kim đồng hồ và hậu tố 2có nghĩa là, mặt được quay 180 độ theo chiều kim đồng hồ.

Bạn có bất kỳ vấn đề nào với ký hiệu này, chỉ cần sử dụng http://ache.cubing.net , nơi bạn có thể hình dung các chuỗi di chuyển như vậy.

Các thách thức

Nhiệm vụ của bạn là viết một chương trình, xác định xem một chuỗi di chuyển có phải là danh tính hay không.

Bạn có thể viết một chương trình đầy đủ hoặc một chức năng. Nó sẽ nhận được một chuỗi chứa chuỗi di chuyển (di chuyển được phân tách bằng dấu cách) làm đầu vào (thông qua STDIN, đối số dòng lệnh, đối số nhắc hoặc hàm) và đầu ra (thông qua giá trị trả về hoặc STDOUT) một giá trị Boolean hoặc một số nguyên tương ứng ( Đúng - 1 - chuỗi nhận dạng / Sai - 0 - không phải chuỗi nhận dạng).

Nếu hậu tố của bạn 'tạo ra các vấn đề trong ngôn ngữ lập trình của bạn, bạn có thể sử dụng một ký hiệu khác, nhưng không phải là chữ số. R F2 U3không được đồng ý.

Đây là codegolf, do đó mã ngắn nhất (tính bằng byte) sẽ thắng.

Các trường hợp thử nghiệm

"" -> True
"U2 R R' U2" -> True
"U D2 U' D2" -> True
"U2 R U2 R'" -> False
"R' U' R' F' U F U' R' F R F' U' R U2 R" -> True
"L'" -> False
"B B2 B' B2" -> True
"D D2 D'" -> False
"R F' D2 U B' F2 B' U2 D2 F2 B2 U F R'" -> True
"D2 U' R2 U F2 D2 U' R2 U' B' L2 R' B' D2 U B2 L' D' R2" -> False
"R U R' U' R' F R2 U' R' U' R U R' F' R2 U R2 U' R2 U' D R2 U' R2 U R2 D'" -> True
"R U R' U' R' F R2 U' R' U' R U R' F' R2 U' R2 U R2 U' D R2 U' R2 U R2 D'" -> False
"B2 F2 U' F2 U R2 F2 U2 B D' R' D' R2 D' F2 U' F U R2 U R B D B D2 L2 D' F2 U D' R' D B R2 D2 F2 R' F2 D2" -> True
"R U2 R' U R' U2 R U2 R U R' U' R' U R U2" -> False
"U F B' R' U F' R U' F' B L U' F L'" -> False
"R2 U' R' U' R U R U R U' R" -> False
"R' F R' B2 R F' R' B2 R2" -> False

Haskell, 263 261 247 243 ký tự

c[x]=[x]
c(x:"2")=[x,x]
c(x:_)=[x,x,x]
s!a@[x,y,z]=case s of
 'R'|x>0->[x,-z,y]
 'B'|y>0->[z,y,-x]
 'U'|z>0->[-y,x,z]
 'L'|x<0->[x,z,-y]
 'F'|y<0->[-z,y,x]
 'D'|z<0->[y,-x,z]
 _->a
r=[-2..2]
i=mapM id[r,r,r]
f w=i==foldr(map.(!))i(c=<<words w)

Thuật toán khá đơn giản; mỗi khối được tạo thành từ 1,2,4 hoặc 8 khối mã hóa vị trí và hướng của nó; 4 khối mỗi khối cạnh, 8 khối mỗi góc, 7 khối đều đứng yên.

c c homp mỗi từ của đầu vào thành một chuỗi các lượt CW và !gửi từng đoạn theo một lượt. ilà vị trí i nha. flà chính e bôi.

Tôi không quá hài lòng với cchức năng homp, nhưng dường như tôi cũng không thể tìm ra cách rút ngắn nó (tuy nhiên @Nimi đã làm)

Về cơ bản , 6 4 byte

¶=8%

Tôi thắng: P

¶=8%
¶     read a string, evaluate as Cubically code
 =8   set notepad to (notepad == 8th face)
   %  print notepad

Sổ ghi chép được khởi tạo về không. "Mặt" thứ 8 chứa 1 nếu khối không được giải và 0 khác.

Hãy thử trực tuyến!

J - 232, 220, 381, 315 296 byte

Giải pháp này mã hóa tất cả các hoạt động dưới dạng hoán vị khuôn mặt và hoạt động dựa trên thực tế là tất cả các xoắn mặt đều thực sự giống nhau, dưới một vòng quay của toàn bộ khối.

Chỉnh sửa : thêm một số golf

f=:+/~6&*
r=:4 :'y f&.>(]{^:x~)&.C.;/i.2 4'"0
t=:((r~0),_4<\44#.inv 1478253772705907911x)&C.&.
Y=:(C.(,0 2 r 4 5),;/4 f&i.8)&{^:t
X=:((,1 1 0 2 r 2 4 3 1)C.C.;/0 4 2 5 f i.8)&{^:t
61".@A."1'=: ',"#~6 3$'D0XR1YF1XU2YB3XL3Y'
T=:[:(_2".@}.'(i.48)-:'&(,,[))[:(,'^:',])/&.>@|.&.;:[:''''&=@{.`]},:&'3'

Khác với những lần thử trước, điều này không tính đến việc xoay góc.

fchỉ là một chức năng của người trợ giúp. rkhông quay một mặt. một khuôn mặt được mã hóa như sau:

1. tất cả các góc trong bước 6
2. tất cả các cạnh trong bước sáu

thứ tự này tạo điều kiện cho việc mã hóa các phép quay và xoắn. tlà một trạng từ xoắn khuôn mặt dưới một vòng quay hình khối nhất định, chọn khuôn mặt.

Xvà Ylà các trạng từ lấy tham số trái số lượng theo hướng đó của toàn bộ khối.

Dòng tiếp theo xác định tất cả các phép quay: 3 ký tự trên mỗi vòng quay: tên, số lần quay và hướng.

Dòng cuối cùng xác định động từ kiểm tra T, chuyển đổi 3 và 'thành ký hiệu Power, lật thứ tự thao tác nối thêm vectơ kiểm tra và cuối cùng là trích xuất toàn bộ.

Thêm chi tiết theo yêu cầu.

tests =: (] ;. _2) 0 : 0

 U2 R R' U2
 U D2 U' D2
 U2 R2 R'
 R' U' R' F' U F U' R' F R F' U' R U2 R
 L'
 B B2 B' B2
 D D2 D'
 R F' D2 U B' F2 B' U2 D2 F2 B2 U F R'
 D2 U' R2 U F2 D2 U' R2 U' B' L2 R' B' D2 U B2 L' D' R2
 R U R' U' R' F R2 U' R' U' R U R' F' R2 U R2 U' R2 U' D R2 U' R2 U R2 D'
 R U R' U' R' F R2 U' R' U' R U R' F' R2 U' R2 U R2 U' D R2 U' R2 U R2 D'
 B2 F2 U' F2 U R2 F2 U2 B D' R' D' R2 D' F2 U' F U R2 U R B D B D2 L2 D' F2 U D' R' D B R2 D2 F2 R' F2 D2
 R U2 R' U R' U2 R U2 R U R' U' R' U R U2
 U F B' R' U F' R U' F' B L U' F L'
 R2 U' R' U' R U R U R U' R
 R' F R' B2 R F' R' B2 R2
)
res =: 1 1 1 0 1 0 1 0 1 0 1 0 1 0 0 0 0
res ([,],:=) T"1 tests NB. passes all tests.
1 1 1 0 1 0 1 0 1 0 1 0 1 0 0 0 0
1 1 1 0 1 0 1 0 1 0 1 0 1 0 0 0 0
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

NB. some handy display methods:
dispOrig=: (". ;._2) 0 :0
   _   _   _   5  29  11   _   _   _   _   _   _
   _   _   _  47  _1  35   _   _   _   _   _   _
   _   _   _  23  41  17   _   _   _   _   _   _
   3  27   9   0  24   6   1  25   7   2  26   8
  45  _3  33  42  _6  30  43  _5  31  44  _4  32
  21  39  15  18  36  12  19  37  13  20  38  14
   _   _   _   4  28  10   _   _   _   _   _   _
   _   _   _  46  _2  34   _   _   _   _   _   _
   _   _   _  22  40  16   _   _   _   _   _   _
)
ind =: dispOrig i.&, i. 48 NB. indices of i.48 in the original display

disp =: (9 12$(,dispOrig) ind}~ ])
changed =: 1 : '(u ~:&disp ]) i.48' NB. use to debug permutation verbs: L ch
vch =: 1 :'disp  ((]+_*=) u)'
NB. viewmat integration RGB
cm =: 255 * 1 0 0 , 1 1 1, 0 1 0, 1 1 0, 1 0.5 0, 0 0 1,: 0 0 0 NB. colormap
NB. use as:  "cube i. 48" for seeing a nice folded out cube.
cube =: cm viewmat (>&7 + >&15 + >&23 + >&31 + >& 39 + >&47)@|@disp@]

Python 3: 280 ký tự

Đây không phải là một người tham gia vào thử thách. Thứ nhất vì tôi đã tự hỏi thử thách và thứ hai vì đó không phải là mã của tôi. Tất cả các khoản tín dụng thuộc về Stefan Pochmann , người đã khám phá ra cách mô phỏng tuyệt vời này của Rubik's Cube. Tôi chỉ chơi golf và một số thay đổi nhỏ liên quan đến thử thách.

def f(a):
 s=t="UF UR UB UL DF DR DB DL FR FL BR BL UFR URB UBL ULF DRF DFL DLB DBR".split()
 for m in a.split():q="FLBR FRBL FDBU FUBD URDL ULDR".split()['UDLRFB'.index(m[0])];n=2+"2'".find(m[-1]);s=[[p,p.translate(str.maketrans(q,q[n:]+q[:n]))][m[0]in p]for p in s]
 return s==t

Ý tưởng đằng sau này là như sau. sđại diện cho vị trí của mảnh UF, URvà vân vân. Ví dụ: s = ['DF', 'BL', ...]có nghĩa là, mảnhUF ở vị trí DF, mảnh URở vị trí BL, ...

Làm thế nào để vị trí của một mảnh thay đổi, khi thực hiện một di chuyển. Nếu bạn thực hiện một U-move, tất cả các nhãn dán (màu sắc) của U-layer, đối diện với mặt trước, di chuyển sang mặt trái. Các nhãn dán của mặt trái di chuyển ra phía sau, những cái này ở bên phải và những cái này vào mặt trước. Được mã hóa bởi FLBR. Một số ví dụ: UFdi chuyển đến UL, UFRdi chuyển đến ULFvà như vậy. Do đó, áp dụng một động tác chỉ đơn giản là dịch các mặt của các mảnh trong lớp tương ứng.