逆时针旋转字节数组

Question

预期的结果是逆时针旋转字节数组，以获得一个固定的“a”。

我试图将给定的数组转换为旋转版本，但效果不佳。我的代码在“loop（）”中的位移位和计算部分有一些不正确的地方。因此，我不得不分别处理x==5和x==6。

我如何在C中以更一般的方式逆时针旋转字节数组？

代码：

#include "LedControl.h"
LedControl lc=LedControl(12,11,10,4);

void setup(){
  for (int addr=0; addr<lc.getDeviceCount(); addr++){
    lc.shutdown(addr,false);
    lc.setIntensity(addr,0);
    lc.clearDisplay(addr);
  }
}

void loop(){
  // given
  byte a[5]={B01111110,B00010001,B00010001,B01111110,B00000000};

  // expected
  byte a2[8]={B01100000,B10010000,B10010000,B10010000,B11110000,B10010000,B10010000,B00000000};

  // rotated
  byte a3[8];
  byte row;
  for (int x = 0; x < 8; x++){
    row = B00000000;
    for (int y = 0; y < 5; y++){
      if (x==0 || x==1 || x==2 || x==3 || x==4) {
        row |= (a[y] & B00000001 << x) << 7-x-y;
      }
      if (x==5) {
        row |= (a[0] & B00100000) << 2;
        row |= (a[1] & B00100000) << 1;
        row |= (a[2] & B00100000);
        row |= (a[3] & B00100000) >> 1;
      }
      if (x==6) {
        row |= (a[0] & B01000000) << 1;
        row |= (a[1] & B01000000);
        row |= (a[2] & B01000000) >> 1;
        row |= (a[3] & B01000000) >> 2;
      }
    }
    a3[x] = row;
  }

  // output
  for(int i=0; i<8; i++){
    lc.setRow(0,i,a[i]); // given
    lc.setRow(1,i,a2[i]); // expected
    lc.setRow(2,i,a3[i]); // rotated
    delay(100);
  }
}

输出LED：

given a            expected a2
                   rotated a3

_ o o o o o o _    _ o o _ _ _ _ _
_ _ _ o _ _ _ o    o _ _ o _ _ _ _
_ _ _ o _ _ _ o    o _ _ o _ _ _ _
_ o o o o o o _    o _ _ o _ _ _ _
_ _ _ _ _ _ _ _    o o o o _ _ _ _
_ _ _ _ _ _ _ _    o _ _ o _ _ _ _
_ _ _ _ _ _ _ _    o _ _ o _ _ _ _
_ _ _ _ _ _ _ _    _ _ _ _ _ _ _ _

Answer 1

你的代码看起来真的太过分了。您可以使用嵌套循环来迭代源数据的每一个可能的位，并相应地设置dest数据（这基本上是交换索引），类似于：

#include <stdio.h>

typedef unsigned char byte;

void printCharacter(const byte* data, size_t length)
{
  for (size_t i = 0; i < length; ++i)
  {
    for (size_t j = 0; j < 8; ++j)
    {
      const unsigned char mask = 1 << j;
      printf("%c ", data[i] & mask ? 'o' : '-');
    }
    printf("\n");
  }
}

void rotate(const byte* source, byte* dest, size_t length)
{
  /* for each bit position starting from first */
  for (size_t j = 0; j < 8; ++j)
  {
    /* this is the mask of the i-th bit in source data */
    const unsigned char mask = 1 << j;

    /* for each row in source data (which will become column) */
    for (size_t i = 0; i < length; ++i)
    {
      /* if j-th bit of i-th row set */
      if (source[i] & mask)
      /* then set i-th bit of j-th row */
        dest[j] |= 1 << i;
    }
  }
}

int main() {
  byte a[5]= { 0b01111110,0b00010001,0b00010001,0b01111110,0b00000000 };
  byte b[8]= { 0 };
  printCharacter(a, 5);
  rotate(a, b, 5);
  printCharacter(b, 8);
  return 0;
}

现在这个输出

- o o o o o o - 
o - - - o - - - 
o - - - o - - - 
- o o o o o o - 
- - - - - - - - 

- o o - - - - - 
o - - o - - - - 
o - - o - - - - 
o - - o - - - - 
o o o o - - - - 
o - - o - - - - 
o - - o - - - - 
- - - - - - - - 

这并不完全是您正在寻找的，但您只需要调整掩码/索引，以根据您想要的旋转从第一个/最后一个位开始。