Diberikan array 3D biner, untuk setiap lapisan, putar secara siklikal ke atas setiap kolomnya sebanyak langkah sebagaimana ditunjukkan oleh pengodean biner dari kolom lapisan di atasnya, dan kemudian putar secara siklik ke kiri setiap barisnya sebanyak langkah seperti yang ditunjukkan oleh pengkodean biner dari baris-baris lapisan di bawahnya.

Akan selalu ada setidaknya tiga lapisan. Kolom lapisan atas dan baris lapisan bawah tidak boleh diputar.

Walk-through

Mari kita mulai dengan array 4-layer, 2-baris, 3-kolom kecil:

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

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

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

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

Langkah pertama adalah mengevaluasi angka-angka yang dikodekan dalam biner oleh kolom dan baris setiap lapisan:

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

Lapisan pertama, [[1,0,1],[1,0,0]]tidak akan memiliki kolomnya diputar, tetapi barisnya akan diputar secara siklis, masing-masing tersisa 5 langkah dan 3 langkah, sehingga menjadi [[1,1,0],[1,0,0]].
 Lapisan kedua [[1,0,1],[0,1,1]],, akan memiliki kolomnya diputar secara siklis masing-masing hingga 3, 0, dan 2 langkah, memberi [[0,0,1],[1,1,1]], dan kemudian baris-baris tersebut diputar secara siklik ke kiri masing-masing 3 dan 7 langkah, tanpa perubahan yang terlihat.
 Lapisan ketiga, [[0,1,1],[1,1,1]]diputar ke atas 2, 1, dan 3 langkah tetap sama, dan juga tidak berputar kiri 6 dan 7 langkah melakukan apa pun.
 Akhirnya, lapisan keempat, [[1,1,0],[1,1,1]]diputar ke atas langkah 1, 3, dan 3 adalah [[1,1,1],[1,1,0]], tetapi barisnya tidak diputar setelah itu, karena itu adalah lapisan terakhir.
 Menyatukan semua layer lagi, memberi kita array 3D self-rotated biner:

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

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

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

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

Contoh kasus:

[[[1,0,1],[1,0,0]],[[1,0,1],[0,1,1]],[[0,1,1],[1,1,1]],[[1,1,0],[1,1,1]]] memberi
[[[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]]] memberi
[[[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]]] memberi
[[[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]]]

Jelly ,  18  17 byte

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

Cobalah online!

Bagaimana?

ṙ""Ḅ} - 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) )

_{Catatan: $$(atau mungkin $$ ... $$?) Tampaknya mengacaukan pemformatan kode-blok (tetapi hanya sekali diposting, tidak dalam pratinjau), jadi saya menambahkan spasi untuk membuat hidup saya lebih mudah.}

Python 2 , 220 211 209 185 176 174 164 161 159 byte

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

Cobalah online!

_{-2 byte, terima kasih kepada Jonathan Allan}

APL + WIN, 53 39 byte

Terima kasih banyak untuk Adim karena telah menghemat 14 byte

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

Cobalah online! Atas perkenan Dyalog Classic

Meminta input array 3d dari formulir:

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

yang menghasilkan:

1 0 1
1 0 0

1 0 1
0 1 1

0 1 1
1 1 1

1 1 0
1 1 1

Penjelasan:

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 byte

-21 byte berkat 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}

Cobalah online!

05AB1E , 41 39 byte

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

Ini terasa terlalu lama .. Pasti bisa bermain golf lagi.

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

ε                    # 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)

Bahasa Wolfram (Mathematica) , 138 131 125 123 byte

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}&

Cobalah online!

• Map[Thread]setara dengan Transpose[a, {1,3,2}], yang mentransposisi kolom dan baris.
• Fold[#+##&]lebih pendek daripada IntegerDigits[#,2]untuk mengkonversi dari biner.