Надаючи двійковий 3D-масив, для кожного шару циклічно обертайте кожен свій стовпець на стільки кроків, на які вказує двійкове кодування стовпців шару над ним, а потім циклічно обертайте ліворуч кожен його рядок стільки кроків, скільки вказано двійкове кодування рядків шару під ним.

Завжди буде як мінімум три шари. Стовпці верхнього шару та рядки нижнього шару не повинні повертатися.

Прохідний

Почнемо з невеликого 4-шарового, дворядного, 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 байти, завдяки Джонатану Аллану}

APL + WIN, 53 39 байт

Велика подяка Адаму за збереження 14 байт

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

Спробуйте в Інтернеті! Надано Dyalog Classic

Підказки для введення 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

який дає:

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)

Мова Вольфрама (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]для перетворення з двійкового.