Binary self-rotation












6












$begingroup$


Given a binary 3D array, for each layer, cyclically rotate up each of its columns as many steps as indicated by the binary encoding of the columns of the layer above it, and then cyclically rotate left each of its rows as many steps as indicated by the binary encoding of the rows of the layer below it.



There will always be at least three layers. The top layer's columns and the bottom layer's rows should not be rotated.



Walk-through



Lets start with the small 4-layer, 2-row, 3-column array:



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

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

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

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


The first step is evaluating the numbers encoded in binary by the columns and rows of each layer:



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


The first layer, [[1,0,1],[1,0,0]] will not have its columns rotated, but its rows will be cyclically rotated left 5 steps and 3 step respectively, thus becoming [[1,1,0],[1,0,0]].

 The second layer, [[1,0,1],[0,1,1]], will have its columns cyclically rotated up 3, 0, and 2 steps respectively, giving [[0,0,1],[1,1,1]], and then the rows are cyclically rotated left 3 and 7 steps respectively, with no visible change.

 The third layer, [[0,1,1],[1,1,1]] rotated up 2, 1, and 3 steps stays the same, and neither does rotating left 6 and 7 steps do anything.

 Finally, the fourth layer, [[1,1,0],[1,1,1]] rotated up 1, 3, and 3 steps is [[1,1,1],[1,1,0]], but its rows are not rotated afterwards, as it is the last layer.

 Putting all the layers together again, gives us the binary self-rotated 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]]]


Example cases:



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










share|improve this question









$endgroup$

















    6












    $begingroup$


    Given a binary 3D array, for each layer, cyclically rotate up each of its columns as many steps as indicated by the binary encoding of the columns of the layer above it, and then cyclically rotate left each of its rows as many steps as indicated by the binary encoding of the rows of the layer below it.



    There will always be at least three layers. The top layer's columns and the bottom layer's rows should not be rotated.



    Walk-through



    Lets start with the small 4-layer, 2-row, 3-column array:



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

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

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

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


    The first step is evaluating the numbers encoded in binary by the columns and rows of each layer:



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


    The first layer, [[1,0,1],[1,0,0]] will not have its columns rotated, but its rows will be cyclically rotated left 5 steps and 3 step respectively, thus becoming [[1,1,0],[1,0,0]].

     The second layer, [[1,0,1],[0,1,1]], will have its columns cyclically rotated up 3, 0, and 2 steps respectively, giving [[0,0,1],[1,1,1]], and then the rows are cyclically rotated left 3 and 7 steps respectively, with no visible change.

     The third layer, [[0,1,1],[1,1,1]] rotated up 2, 1, and 3 steps stays the same, and neither does rotating left 6 and 7 steps do anything.

     Finally, the fourth layer, [[1,1,0],[1,1,1]] rotated up 1, 3, and 3 steps is [[1,1,1],[1,1,0]], but its rows are not rotated afterwards, as it is the last layer.

     Putting all the layers together again, gives us the binary self-rotated 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]]]


    Example cases:



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










    share|improve this question









    $endgroup$















      6












      6








      6





      $begingroup$


      Given a binary 3D array, for each layer, cyclically rotate up each of its columns as many steps as indicated by the binary encoding of the columns of the layer above it, and then cyclically rotate left each of its rows as many steps as indicated by the binary encoding of the rows of the layer below it.



      There will always be at least three layers. The top layer's columns and the bottom layer's rows should not be rotated.



      Walk-through



      Lets start with the small 4-layer, 2-row, 3-column array:



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

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

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

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


      The first step is evaluating the numbers encoded in binary by the columns and rows of each layer:



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


      The first layer, [[1,0,1],[1,0,0]] will not have its columns rotated, but its rows will be cyclically rotated left 5 steps and 3 step respectively, thus becoming [[1,1,0],[1,0,0]].

       The second layer, [[1,0,1],[0,1,1]], will have its columns cyclically rotated up 3, 0, and 2 steps respectively, giving [[0,0,1],[1,1,1]], and then the rows are cyclically rotated left 3 and 7 steps respectively, with no visible change.

       The third layer, [[0,1,1],[1,1,1]] rotated up 2, 1, and 3 steps stays the same, and neither does rotating left 6 and 7 steps do anything.

       Finally, the fourth layer, [[1,1,0],[1,1,1]] rotated up 1, 3, and 3 steps is [[1,1,1],[1,1,0]], but its rows are not rotated afterwards, as it is the last layer.

       Putting all the layers together again, gives us the binary self-rotated 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]]]


      Example cases:



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










      share|improve this question









      $endgroup$




      Given a binary 3D array, for each layer, cyclically rotate up each of its columns as many steps as indicated by the binary encoding of the columns of the layer above it, and then cyclically rotate left each of its rows as many steps as indicated by the binary encoding of the rows of the layer below it.



      There will always be at least three layers. The top layer's columns and the bottom layer's rows should not be rotated.



      Walk-through



      Lets start with the small 4-layer, 2-row, 3-column array:



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

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

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

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


      The first step is evaluating the numbers encoded in binary by the columns and rows of each layer:



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


      The first layer, [[1,0,1],[1,0,0]] will not have its columns rotated, but its rows will be cyclically rotated left 5 steps and 3 step respectively, thus becoming [[1,1,0],[1,0,0]].

       The second layer, [[1,0,1],[0,1,1]], will have its columns cyclically rotated up 3, 0, and 2 steps respectively, giving [[0,0,1],[1,1,1]], and then the rows are cyclically rotated left 3 and 7 steps respectively, with no visible change.

       The third layer, [[0,1,1],[1,1,1]] rotated up 2, 1, and 3 steps stays the same, and neither does rotating left 6 and 7 steps do anything.

       Finally, the fourth layer, [[1,1,0],[1,1,1]] rotated up 1, 3, and 3 steps is [[1,1,1],[1,1,0]], but its rows are not rotated afterwards, as it is the last layer.

       Putting all the layers together again, gives us the binary self-rotated 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]]]


      Example cases:



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







      code-golf matrix cellular-automata 3d






      share|improve this question













      share|improve this question











      share|improve this question




      share|improve this question










      asked 5 hours ago









      AdámAdám

      29.6k271194




      29.6k271194






















          3 Answers
          3






          active

          oldest

          votes


















          0












          $begingroup$


          05AB1E, 41 39 bytes



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


          This feels way too long.. Can definitely be golfed some more.



          Try it online or verify all test cases.



          Explanation:





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





          share|improve this answer











          $endgroup$





















            0












            $begingroup$


            Jelly,  18  17 bytes



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


            Try it online!



            Code description will be added in five hours or so.






            share|improve this answer











            $endgroup$





















              0












              $begingroup$


              Python 2, 220 211 209 bytes





              lambda m:[R(R(l,x),y)for l,x,y in z(m,[[0]]+[map(b,z(*l))for l in m],[map(b,l)for l in m[1:]]+[[0]])]
              b=lambda r:int(''.join(map(str,r)),2)%len(r)
              R=lambda l,x:[r[i:]+r[:i]for i,r in z(x*len(`l`),z(*l))]
              z=zip


              Try it online!






              share|improve this answer











              $endgroup$













                Your Answer





                StackExchange.ifUsing("editor", function () {
                return StackExchange.using("mathjaxEditing", function () {
                StackExchange.MarkdownEditor.creationCallbacks.add(function (editor, postfix) {
                StackExchange.mathjaxEditing.prepareWmdForMathJax(editor, postfix, [["\$", "\$"]]);
                });
                });
                }, "mathjax-editing");

                StackExchange.ifUsing("editor", function () {
                StackExchange.using("externalEditor", function () {
                StackExchange.using("snippets", function () {
                StackExchange.snippets.init();
                });
                });
                }, "code-snippets");

                StackExchange.ready(function() {
                var channelOptions = {
                tags: "".split(" "),
                id: "200"
                };
                initTagRenderer("".split(" "), "".split(" "), channelOptions);

                StackExchange.using("externalEditor", function() {
                // Have to fire editor after snippets, if snippets enabled
                if (StackExchange.settings.snippets.snippetsEnabled) {
                StackExchange.using("snippets", function() {
                createEditor();
                });
                }
                else {
                createEditor();
                }
                });

                function createEditor() {
                StackExchange.prepareEditor({
                heartbeatType: 'answer',
                autoActivateHeartbeat: false,
                convertImagesToLinks: false,
                noModals: true,
                showLowRepImageUploadWarning: true,
                reputationToPostImages: null,
                bindNavPrevention: true,
                postfix: "",
                imageUploader: {
                brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
                contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
                allowUrls: true
                },
                onDemand: true,
                discardSelector: ".discard-answer"
                ,immediatelyShowMarkdownHelp:true
                });


                }
                });














                draft saved

                draft discarded


















                StackExchange.ready(
                function () {
                StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodegolf.stackexchange.com%2fquestions%2f178984%2fbinary-self-rotation%23new-answer', 'question_page');
                }
                );

                Post as a guest















                Required, but never shown

























                3 Answers
                3






                active

                oldest

                votes








                3 Answers
                3






                active

                oldest

                votes









                active

                oldest

                votes






                active

                oldest

                votes









                0












                $begingroup$


                05AB1E, 41 39 bytes



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


                This feels way too long.. Can definitely be golfed some more.



                Try it online or verify all test cases.



                Explanation:





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





                share|improve this answer











                $endgroup$


















                  0












                  $begingroup$


                  05AB1E, 41 39 bytes



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


                  This feels way too long.. Can definitely be golfed some more.



                  Try it online or verify all test cases.



                  Explanation:





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





                  share|improve this answer











                  $endgroup$
















                    0












                    0








                    0





                    $begingroup$


                    05AB1E, 41 39 bytes



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


                    This feels way too long.. Can definitely be golfed some more.



                    Try it online or verify all test cases.



                    Explanation:





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





                    share|improve this answer











                    $endgroup$




                    05AB1E, 41 39 bytes



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


                    This feels way too long.. Can definitely be golfed some more.



                    Try it online or verify all test cases.



                    Explanation:





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






                    share|improve this answer














                    share|improve this answer



                    share|improve this answer








                    edited 4 hours ago

























                    answered 4 hours ago









                    Kevin CruijssenKevin Cruijssen

                    36.6k555192




                    36.6k555192























                        0












                        $begingroup$


                        Jelly,  18  17 bytes



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


                        Try it online!



                        Code description will be added in five hours or so.






                        share|improve this answer











                        $endgroup$


















                          0












                          $begingroup$


                          Jelly,  18  17 bytes



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


                          Try it online!



                          Code description will be added in five hours or so.






                          share|improve this answer











                          $endgroup$
















                            0












                            0








                            0





                            $begingroup$


                            Jelly,  18  17 bytes



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


                            Try it online!



                            Code description will be added in five hours or so.






                            share|improve this answer











                            $endgroup$




                            Jelly,  18  17 bytes



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


                            Try it online!



                            Code description will be added in five hours or so.







                            share|improve this answer














                            share|improve this answer



                            share|improve this answer








                            edited 47 mins ago

























                            answered 1 hour ago









                            Jonathan AllanJonathan Allan

                            51.3k535166




                            51.3k535166























                                0












                                $begingroup$


                                Python 2, 220 211 209 bytes





                                lambda m:[R(R(l,x),y)for l,x,y in z(m,[[0]]+[map(b,z(*l))for l in m],[map(b,l)for l in m[1:]]+[[0]])]
                                b=lambda r:int(''.join(map(str,r)),2)%len(r)
                                R=lambda l,x:[r[i:]+r[:i]for i,r in z(x*len(`l`),z(*l))]
                                z=zip


                                Try it online!






                                share|improve this answer











                                $endgroup$


















                                  0












                                  $begingroup$


                                  Python 2, 220 211 209 bytes





                                  lambda m:[R(R(l,x),y)for l,x,y in z(m,[[0]]+[map(b,z(*l))for l in m],[map(b,l)for l in m[1:]]+[[0]])]
                                  b=lambda r:int(''.join(map(str,r)),2)%len(r)
                                  R=lambda l,x:[r[i:]+r[:i]for i,r in z(x*len(`l`),z(*l))]
                                  z=zip


                                  Try it online!






                                  share|improve this answer











                                  $endgroup$
















                                    0












                                    0








                                    0





                                    $begingroup$


                                    Python 2, 220 211 209 bytes





                                    lambda m:[R(R(l,x),y)for l,x,y in z(m,[[0]]+[map(b,z(*l))for l in m],[map(b,l)for l in m[1:]]+[[0]])]
                                    b=lambda r:int(''.join(map(str,r)),2)%len(r)
                                    R=lambda l,x:[r[i:]+r[:i]for i,r in z(x*len(`l`),z(*l))]
                                    z=zip


                                    Try it online!






                                    share|improve this answer











                                    $endgroup$




                                    Python 2, 220 211 209 bytes





                                    lambda m:[R(R(l,x),y)for l,x,y in z(m,[[0]]+[map(b,z(*l))for l in m],[map(b,l)for l in m[1:]]+[[0]])]
                                    b=lambda r:int(''.join(map(str,r)),2)%len(r)
                                    R=lambda l,x:[r[i:]+r[:i]for i,r in z(x*len(`l`),z(*l))]
                                    z=zip


                                    Try it online!







                                    share|improve this answer














                                    share|improve this answer



                                    share|improve this answer








                                    edited 14 mins ago

























                                    answered 20 mins ago









                                    TFeldTFeld

                                    14.6k21241




                                    14.6k21241






























                                        draft saved

                                        draft discarded




















































                                        If this is an answer to a challenge…




                                        • …Be sure to follow the challenge specification. However, please refrain from exploiting obvious loopholes. Answers abusing any of the standard loopholes are considered invalid. If you think a specification is unclear or underspecified, comment on the question instead.


                                        • …Try to optimize your score. For instance, answers to code-golf challenges should attempt to be as short as possible. You can always include a readable version of the code in addition to the competitive one.
                                          Explanations of your answer make it more interesting to read and are very much encouraged.


                                        • …Include a short header which indicates the language(s) of your code and its score, as defined by the challenge.



                                        More generally…




                                        • …Please make sure to answer the question and provide sufficient detail.


                                        • …Avoid asking for help, clarification or responding to other answers (use comments instead).





                                        draft saved


                                        draft discarded














                                        StackExchange.ready(
                                        function () {
                                        StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodegolf.stackexchange.com%2fquestions%2f178984%2fbinary-self-rotation%23new-answer', 'question_page');
                                        }
                                        );

                                        Post as a guest















                                        Required, but never shown





















































                                        Required, but never shown














                                        Required, but never shown












                                        Required, but never shown







                                        Required, but never shown

































                                        Required, but never shown














                                        Required, but never shown












                                        Required, but never shown







                                        Required, but never shown







                                        Popular posts from this blog

                                        How to label and detect the document text images

                                        Vallis Paradisi

                                        Tabula Rosettana