Cho một mảng 3D nhị phân, đối với mỗi lớp, xoay vòng theo từng cột của nó theo nhiều bước như được chỉ định bởi mã hóa nhị phân của các cột của lớp bên trên, và sau đó xoay vòng trái mỗi hàng theo nhiều bước như được chỉ ra bởi mã hóa nhị phân của các hàng của lớp bên dưới nó.

Sẽ luôn có ít nhất ba lớp. Các cột của lớp trên cùng và các hàng của lớp dưới cùng không được xoay.

Đi qua

Hãy bắt đầu với mảng 4 lớp nhỏ, 2 hàng, 3 cột:

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

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

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

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

Bước đầu tiên là đánh giá các số được mã hóa nhị phân theo các cột và hàng của mỗi lớp:

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

Lớp đầu tiên, [[1,0,1],[1,0,0]]sẽ không có các cột được xoay, nhưng các hàng của nó sẽ được xoay theo chu kỳ lần lượt 5 bước và 3 bước tương ứng [[1,1,0],[1,0,0]].
 Lớp thứ hai [[1,0,1],[0,1,1]], sẽ có các cột được xoay theo chu kỳ lần lượt 3, 0 và 2 bước [[0,0,1],[1,1,1]], sau đó các hàng được xoay theo chu kỳ 3 và 7 bước tương ứng, không có thay đổi rõ ràng.
 Lớp thứ ba, [[0,1,1],[1,1,1]]xoay lên 2, 1 và 3 bước giữ nguyên, và không xoay trái 6 và 7 bước làm bất cứ điều gì.
 Cuối cùng, lớp thứ tư, [[1,1,0],[1,1,1]]xoay lên 1, 3 và 3 bước là [[1,1,1],[1,1,0]], nhưng các hàng của nó không được xoay sau đó, vì nó là lớp cuối cùng.
 Đặt tất cả các lớp lại với nhau, cung cấp cho chúng ta mảng 3D tự xoay nhị phân:

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

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

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

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

Ví dụ trường hợp:

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

Thạch ,  18  17 byte

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

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

Làm sao?

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

_{Lưu ý: $$(hoặc có thể$$ ... $$ ?) Dường như làm xáo trộn định dạng khối mã (nhưng chỉ một lần được đăng, không phải trong bản xem trước), vì vậy tôi đã thêm một khoảng trắng để làm cho cuộc sống của tôi dễ dàng hơn.}

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

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

_{-2 byte, nhờ Jonathan Allan}

APL + THẮNG, 53 39 byte

Rất cám ơn Adám đã lưu 14 byte

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

Hãy thử trực tuyến! Lịch sự của Dyalog Classic

Lời nhắc cho đầu vào của một mảng 3d có dạng:

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

mang lại:

1 0 1
1 0 0

1 0 1
0 1 1

0 1 1
1 1 1

1 1 0
1 1 1

Giải trình:

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 nhờ 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}

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

05AB1E , 41 39 byte

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

Cảm giác này quá dài .. Chắc chắn có thể được đánh gôn thêm.

Dùng thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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

Ngôn ngữ Wolfram (Mathicala) , 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}&

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

• Map[Thread] tương đương với Transpose[a, {1,3,2}] , chuyển đổi các cột và hàng.
• Fold[#+##&]ngắn hơn IntegerDigits[#,2]để chuyển đổi từ nhị phân.