İkili bir 3D dizisi verildiğinde, her katman için sütunlarının her birini, üzerindeki katmanın sütunlarının ikili kodlamasıyla gösterildiği kadar döngüsel olarak yukarı döndürün ve ardından satırlarının her birini belirtildiği kadar döngüsel olarak sola döndürün altındaki katmanın satırlarının ikili kodlaması.

Her zaman en az üç katman olacaktır. Üst katmanın sütunları ve alt katmanın satırları döndürülmemelidir.

Walk-yoluyla

Küçük 4 katmanlı, 2 satırlı, 3 sütunlu dizi ile başlayalım:

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

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

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

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

İlk adım, her katmanın sütunları ve satırları tarafından ikili olarak kodlanan sayıları değerlendirmektir:

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

İlk katman, [[1,0,1],[1,0,0]]sütunlarını döndürmeyecektir, ancak sıraları sırasıyla 5 adım ve 3 adımda döngüsel olarak döndürülecek ve böylece olacaktır [[1,1,0],[1,0,0]].
 İkinci katman, [[1,0,1],[0,1,1]]sütunlarını sırasıyla 3, 0 ve 2 basamaklar [[0,0,1],[1,1,1]]halinde periyodik olarak döndürecek ve satırlar sırasıyla 3 ve 7 basamaklar halinde, görünür bir değişiklik olmadan sırasıyla döngüsel olarak sola döndürülecektir. 2, 1 ve 3 basamak yukarı döndürülmüş
 üçüncü katman [[0,1,1],[1,1,1]]aynı kalır ve sola 6 ve 7 adım döndürmek de hiçbir şey yapmaz.
 Son olarak, [[1,1,0],[1,1,1]]1, 3 ve 3 adım yukarı döndürülen dördüncü katman, [[1,1,1],[1,1,0]]ancak son katman olduğu için sıraları daha sonra döndürülmez.
 Tüm katmanları tekrar bir araya getirmek, kendiliğinden dönen ikili 3D dizisini verir:

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

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

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

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

Örnek durumlar:

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

Jöle ,  18  17 bayt

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

Çevrimiçi deneyin!

Nasıl?

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

_{Not: $$(veya muhtemelen $$ ... $$?) Kod bloğu biçimlendirmesini bozuyor gibi görünüyor (ancak önizlemede değil, yalnızca bir kez gönderildi), bu yüzden hayatımı kolaylaştırmak için bir boşluk ekledim.}

Piton 2 , 220 211 209 185 176 174 164 161 159 bayt

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

Çevrimiçi deneyin!

_{-2 bayt, Jonathan Allan sayesinde}

APL + WIN, 53 39 bayt

Adám'a 14 bayt kazandığı için çok teşekkürler

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

Çevrimiçi deneyin! Dyalog Classic'in izniyle

Formun 3B dizisinin girilmesini ister:

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

hangi verir:

1 0 1
1 0 0

1 0 1
0 1 1

0 1 1
1 1 1

1 1 0
1 1 1

Açıklama:

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 bayt

DigEmAll sayesinde -21 bayt

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}

Çevrimiçi deneyin!

05AB1E , 41 39 bayt

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

Bu çok uzun geliyor .. Kesinlikle biraz daha golf olabilir.

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

Açıklama:

ε                    # 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 Dili (Mathematica) , 138 131 125 123 bayt

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

Çevrimiçi deneyin!

• Map[Thread]Transpose[a, {1,3,2}]sütunlara ve satırlara dönüştüren eşdeğerdir .
• Fold[#+##&]ikiliden IntegerDigits[#,2]dönüştürmekten daha kısadır .