กำหนดอาเรย์ไบนารี 3D สำหรับแต่ละเลเยอร์หมุนรอบแต่ละคอลัมน์เป็นขั้นตอนหลายขั้นตามที่ระบุโดยการเข้ารหัสไบนารีของคอลัมน์ของเลเยอร์ด้านบนแล้วหมุนวนซ้ายแต่ละแถวตามขั้นตอนตามที่กำหนดโดย การเข้ารหัสแบบไบนารีของแถวของเลเยอร์ด้านล่าง

จะมีอย่างน้อยสามชั้นเสมอ คอลัมน์ของชั้นบนสุดและแถวของชั้นล่างไม่ควรหมุน

เดินผ่าน

เริ่มต้นด้วยอาร์เรย์ขนาดเล็ก 4 ชั้น 2 แถว 3 คอลัมน์:

[[[1,0,1],
  [1,0,0]],

 [[1,0,1],
  [0,1,1]],

 [[0,1,1],
  [1,1,1]],

 [[1,1,0],
  [1,1,1]]]

ขั้นตอนแรกคือการประเมินตัวเลขที่เข้ารหัสในเลขฐานสองโดยคอลัมน์และแถวของแต่ละชั้น:

     3 0 2
5 [[[1,0,1],
4   [1,0,0]],

     2 1 3
5  [[1,0,1],
3   [0,1,1]],

     1 3 3
3  [[0,1,1],
7   [1,1,1]],

     3 3 1
6  [[1,1,0],
7   [1,1,1]]]

ชั้นแรก[[1,0,1],[1,0,0]]จะไม่ได้มีคอลัมน์หมุน แต่แถวของมันจะถูกหมุนวนที่เหลือ 5 ขั้นตอนและขั้นตอนที่ 3 [[1,1,0],[1,0,0]]ตามลำดับจึงกลายเป็น
 เลเยอร์ที่สอง[[1,0,1],[0,1,1]]จะมีคอลัมน์ของมันหมุนเป็นวงกลม 3, 0 และ 2 ขั้นตอนตามลำดับการให้[[0,0,1],[1,1,1]]และจากนั้นแถวจะหมุนไปทางซ้าย 3 และ 7 ขั้นตอนตามลำดับโดยไม่มีการเปลี่ยนแปลงที่มองเห็นได้
 เลเยอร์ที่สาม[[0,1,1],[1,1,1]]หมุนได้ 2, 1 และ 3 ขั้นตอนยังคงเหมือนเดิมและไม่มีการหมุนซ้ายและขวา 6 และ 7 ขั้นตอนเพื่อทำสิ่งใด
 ในที่สุดชั้นที่สี่[[1,1,0],[1,1,1]]หมุนขึ้นไป 1, 3 และ 3 ขั้นตอนคือ[[1,1,1],[1,1,0]]แต่แถวของมันจะไม่หมุนหลังจากนั้นเพราะมันเป็นชั้นสุดท้าย
 การรวมเลเยอร์ทั้งหมดเข้าด้วยกันอีกครั้งทำให้เรามีอาร์เรย์ 3D หมุนด้วยตนเองแบบไบนารี:

[[[1,1,0],
  [1,0,0]],

 [[0,0,1],
  [1,1,1]],

 [[0,1,1],
  [1,1,1]],

 [[1,1,1],
  [1,1,0]]]

ตัวอย่างกรณี:

[[[1,0,1],[1,0,0]],[[1,0,1],[0,1,1]],[[0,1,1],[1,1,1]],[[1,1,0],[1,1,1]]] จะช่วยให้
[[[1,1,0],[1,0,0]],[[0,0,1],[1,1,1]],[[0,1,1],[1,1,1]],[[1,1,1],[1,1,0]]]

[[[1]],[[1]],[[0]]] จะช่วยให้
[[[1]],[[1]],[[0]]]

[[[1,0,1],[1,0,1],[1,0,1]],[[0,0,1],[0,0,1],[0,0,1]],[[1,0,0],[1,0,1],[0,0,1]]] จะช่วยให้
[[[0,1,1],[0,1,1],[0,1,1]],[[0,1,0],[1,0,0],[0,1,0]],[[1,0,1],[1,0,1],[0,0,0]]]

เยลลี่ ,  18  17 ไบต์

ṙ""Ḅ}
Z€çŻṖ$$Z€çḊ

ลองออนไลน์!

อย่างไร?

ṙ""Ḅ} - Link 1, rotation helper: 3d matrix to rotate, 3d matrix of rotation instructions
    } - use the right argument for:
   Ḅ  -   un-binary (vectorises) - get the rotation amounts as a 2d matrix
  "   - zip with:
 "    -  zip with:
ṙ     -    rotate (the current row) left by (the current amount)

Z€çŻṖ$ $Z€çḊ - Main Link: 3d matrix, M
Z€           - transpose €ach (layer of M)
       $     - last two links as a monad:
     $       -   last two links as a monad:
   Ż         -     prepend a zero
    Ṗ        -     pop (i.e. remove the tail)
  ç          -   call the last Link as a dyad (i.e. f(Z€ result, ŻṖ$ result) )
        Z€   - transpose €ach (layer of that)
           Ḋ - dequeue (i.e. remove the head layer of M)
          ç  - call the last Link as a dyad (i.e. f(Z€çŻṖ$$Z€ result, Ḋ result) )

_{หมายเหตุ: $$(หรืออาจจะ$$ ... $$?) ดูเหมือนว่าการจัดรูปแบบการบล็อกรหัส (แต่เพียงโพสต์ครั้งเดียวไม่ได้อยู่ในตัวอย่าง) ดังนั้นฉันเพิ่มพื้นที่เพื่อให้ชีวิตของฉันง่ายขึ้น}

Python 2 , 220 211 209 185 176 174 164 161 159 ไบต์

lambda m:map(R,z(map(R,z(m,['']+[z(*l)for l in m])),m[1:]+['']))
R=lambda(l,L):map(lambda r,i:r[i:]+r[:i or 0],z(*l),[int(`b`[1::3],2)%len(b)for b in L])
z=zip

ลองออนไลน์!

_{-2 ไบต์ขอบคุณ Jonathan Allan}

APL + WIN, 53 39 ไบต์

ขอบคุณAdámสำหรับการบันทึก 14 ไบต์

(1 0↓⍉2⊥⍉m⍪0)⌽(¯1 0↓2⊥2 1 3⍉0⍪m)⊖[2]m←⎕

ลองออนไลน์! ความอนุเคราะห์จาก Dyalog Classic

แจ้งให้ป้อนข้อมูลของอาร์เรย์ 3 มิติของแบบฟอร์ม:

4 2 3⍴1 0 1 1 0 0 1 0 1 0 1 1 0 1 1 1 1 1 1 1 0 1 1 1

ซึ่งให้:

1 0 1
1 0 0

1 0 1
0 1 1

0 1 1
1 1 1

1 1 0
1 1 1

คำอธิบาย:

m←⎕ Prompt for input

(¯1 0↓2⊥2 1 3⍉0⍪m) Calculate column rotations

(1 0↓⍉2⊥⍉m⍪0) Calculate row rotations

(...)⌽(...)⊖[2]m Apply column and row rotation and output resulting 3d array:

1 1 0
1 0 0

0 0 1
1 1 1

0 1 1
1 1 1

1 1 1
1 1 0

R , 226 216 205 ไบต์

-21 ไบต์ขอบคุณdigEmAll

function(a,L=`for`){d=dim(b<-a)
r=function(a,n,l=sum(a|1))a[(1:l+sum(n*2^(sum(n|1):1-1))-1)%%l+1]
L(i,I<-2:d[3],L(j,1:d,b[j,,i]<-r(b[j,,i],a[j,,i-1])))
L(i,I-1,L(k,1:d[2],b[,k,i]<-r(b[,k,i],a[,k,i+1])))
b}

ลองออนไลน์!

05AB1E , 41 39 ไบต์

εNĀiø¹N<èøJC‚øε`._}ø}N¹g<Êi¹N>èJC‚øε`._

นี่ให้ความรู้สึกนานเกินไป .. สามารถตีกอล์ฟได้มากกว่านี้อย่างแน่นอน

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

ε                    # Map each layer in the (implicit) input to:
                     # (`N` is the layer-index of this map)
 NĀi                 #  If it is not the first layer:
    ø                #   Zip/transpose the current layer; swapping rows/columns
    ¹N<è             #   Get the `N-1`'th layer of the input
        ø            #   Zip/transpose; swapping rows/columns
         J           #   Join all inner lists (the columns) together
          C          #   And convert it from binary to integer
           ‚         #   Pair it with the current layer's columns we're mapping
            ø        #   Zip/transpose; to pair each integer with a layer's columns
             ε   }   #   Map over these pairs:
              `      #    Push both values of the pair separately to the stack
               ._    #    Rotate the column the integer amount of times
    ø                #   Zip/transpose the rows/columns of the current layer back
   }                 #  Close the if-statement
 N¹g<Êi              #  If this is not the last layer (layer-index-1 != amount_of_layers):
       ¹N>è          #   Get the `N+1`'th layer of the input
           J         #   Join all inner lists (the rows) together
            C        #   And convert it from binary to integer
             ‚       #   Pair it with the current layer's rows we're mapping
              ø      #   Zip/transpose; to pair each integer with a layer's rows
               ε     #   Map over these pairs:
                `    #    Push both values of the pair separately to the stack
                 ._  #    Rotate the row the integer amount of times
                     # (implicitly output the result after the layer-mapping is done)

ภาษา Wolfram (Mathematica) , 138 131 125 123 ไบต์

t=Map@Thread
m=MapThread[r=RotateLeft,#,2]&
b=(a=ArrayPad)[Map@Fold[#+##&]/@#,1]~r~#2~a~-1&
g=m@{t@m@{t@#,t@#~b~-1},#~b~1}&

ลองออนไลน์!

• Map[Thread]เทียบเท่ากับTranspose[a, {1,3,2}]ซึ่งสลับคอลัมน์และแถว
• Fold[#+##&]สั้นกว่าIntegerDigits[#,2]สำหรับการแปลงจากไบนารี