প্রতিটি স্তরের জন্য একটি বাইনারি 3 ডি অ্যারে দেওয়া হয়েছে, তার উপরের স্তরের স্তম্ভগুলির বাইনারি এনকোডিং দ্বারা নির্দেশিত যতগুলি পদক্ষেপ চক্রাকারভাবে তার প্রতিটি কলামকে ঘূর্ণায়মানভাবে ঘোরান এবং তারপরে সারিগুলির বামে যতগুলি পদক্ষেপ নির্দেশিত হয় তেমন চক্রাকারে ঘোরান ate এটির নীচে স্তরটির সারিগুলির বাইনারি এনকোডিং।

সর্বদা কমপক্ষে তিন স্তর থাকবে। উপরের স্তরের কলাম এবং নীচের স্তরের সারিগুলি ঘোরানো উচিত নয়।

হাঁটুন-থ্রু

ছোট 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 ধাপে বক্ররেখায় ঘোরানো হবে, কোনও দৃশ্যমান পরিবর্তন নেই। 2, 1 এবং 3 ধাপ উপরে ঘোরানো
তৃতীয় স্তরটি [[0,1,1],[1,1,1]]একই থাকে এবং বাম দিকে ঘোরানো 6 এবং 7 টি পদক্ষেপ কিছুই করে না।
অবশেষে, চতুর্থ স্তরটি [[1,1,0],[1,1,1]]1, 3 এবং 3 টি ধাপে [[1,1,1],[1,1,0]]আবর্তিত হয় তবে এটির শেষ সারিটি এর সারিগুলি পরে ঘোরানো হয় না it
সমস্ত স্তর আবার একসাথে রাখলে আমাদের বাইনারি স্ব-ঘূর্ণিত 3 ডি অ্যারে দেয়:

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

— আদম
সূত্র

3

জেলি , 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) )

_{দ্রষ্টব্য: $$(বা সম্ভবত $$ ... $$?) কোড-ব্লক ফর্ম্যাটিংটি বিশৃঙ্খলা করে বলে মনে হচ্ছে (তবে কেবল একবার পোস্ট করা হয়েছে, পূর্বরূপে নয়), তাই আমি আমার জীবনকে আরও সহজ করার জন্য একটি স্থান যুক্ত করেছি।}

— জোনাথন অ্যালান
সূত্র

3

পাইথন 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

এটি অনলাইন চেষ্টা করুন!

_{-২ বাইটস, জোনাথন অ্যালানকে ধন্যবাদ}

— TFeld
সূত্র

যেহেতু আপনি Noneঘোরার জন্য টুকরো টুকরো করার সময় পরিচালনা করেন আমি বিশ্বাস করি উভয়ই ['0']হয়ে উঠতে পারে [[]]।

— জোনাথন অ্যালান

@

— জোনাথন অ্যালান

2

এপিএল + উইন, 53 39 বাইট

14 বাইট সংরক্ষণের জন্য অ্যাডামকে অনেক ধন্যবাদ

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

এটি অনলাইন চেষ্টা করুন! সৌজন্যে ডায়ালগ ক্লাসিক

ফর্মের একটি 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

যা ফলন:

ব্যাখ্যা:

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

— গ্রাহাম
সূত্র

ঘেরে দেওয়া এবং ব্যবহারের পরিবর্তে ¨একবারে পুরো অ্যারেটি প্রসেস করুন। এটি অনলাইন চেষ্টা করুন!

— আদম

@ অ্যাডাম অনেক ধন্যবাদ। আমি কেন জানি না যে আমি কেন এটিকে ভেবে ভ্রান্ত পথে চলেছি :( বুড়ো হচ্ছে?

— গ্রাহাম

2

আর , 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}

এটি অনলাইন চেষ্টা করুন!

— হওয়া ASCII শুধুমাত্র
সূত্র

1

05 এ বি 1 ই , 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)

— কেভিন ক্রুইজসেন
সূত্র

0

ওল্ফ্রাম ভাষা (গণিত) , 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]বাইনারি থেকে রূপান্তর চেয়ে সংক্ষিপ্ত ।

— lirtosiast
সূত্র

বাইনারি স্ব-ঘূর্ণন

হাঁটুন-থ্রু

জেলি , 18 17 বাইট

কিভাবে?

পাইথন 2 , 220 211 209 185 176 174 164 161 159 বাইট

এপিএল + উইন, 53 39 বাইট

আর , 226 216 205 বাইট

05 এ বি 1 ই , 41 39 বাইট

ওল্ফ্রাম ভাষা (গণিত) , 138 131 125 123 বাইট