Question

我有一个阵列（比如9个元素），我必须将其视为（3乘3）方格。为了简化问题，这是一个基于单的数组（即索引从1开始而不是0）。

我的目标是确定相对于起点的有效相邻方格。

换句话说，它是如何存储在内存中的：1 2 3 4 5 6 7 8 9

我是如何对待的：
7 8 9
4 5 6
1 2 3

我已经知道如何上下移动并测试越界（1＆gt; = current_index＆lt; = 9）

编辑：我知道上面的测试过于笼统，但它很简单且有效。

//row_size = 3, row_step is -1, 0 or 1 depending on if we're going left,
//staying put or going right respectively.
current_index += (row_size * row_step);

如何向左或向右测试越界条件？从概念上讲，我知道它涉及确定3（例如）是否与4在同一行（或者如果10甚至在与9相同的方格内，作为替代示例，假设多个正方形在背靠背的同一个数组中），但我无法弄清楚如何确定。我想在那里有一个模数，但在哪里？

非常感谢，
杰夫

附录：
这是生成的代码，改为与基于零的数组一起使用（我清理了项目中存在的偏移代码），这些代码遍布相邻的正方形。

bool IsSameSquare(int index0, int index1, int square_size) {
  //Assert for square_size != 0 here
  return (!((index0 < 0) || (index1 < 0))
      && ((index0 < square_size) && (index1 < square_size)))
      && (index0 / square_size == index1 / square_size);
}
bool IsSameRow(int index0, int index1, int row_size) {
  //Assert for row_size != 0 here
  return IsSameSquare(index0, index1, row_size * row_size)
  && (index0 / row_size == index1 / row_size);
}
bool IsSameColumn(int index0, int index1, int row_size) {
  //Assert for row_size != 0 here
  return IsSameSquare(index0, index1, row_size * row_size)
      && (index0 % row_size == index1 % row_size);
}

//for all possible adjacent positions
for (int row_step = -1; row_step < 2; ++row_step) {
  //move up, down or stay put.
  int row_adjusted_position = original_position + (row_size * row_step);
  if (!IsSameSquare(original_position, row_adjusted_position, square_size)) {
    continue;
  }
  for (int column_step = -1; column_step < 2; ++column_step) {
    if ((row_step == 0) & (column_step == 0)) { continue; }
    //hold on to the position that has had its' row position adjusted.
    int new_position = row_adjusted_position;

    if (column_step != 0) {
      //move left or right
      int column_adjusted_position = new_position + column_step;
      //if we've gone out of bounds again for the column.
      if (IsSameRow(column_adjusted_position, new_position, row_size)) {
        new_position = column_adjusted_position;
      } else {
        continue;                          
      }
    } //if (column_step != 0)
    //if we get here we know it's safe, do something with new_position
    //...
  } //for each column_step
} //for each row_step

Answer 1

如果您使用基于0的索引，这会更容易。如果从所有索引中减去1，则这些规则有效：

如果（a / 9）==（b / 9）且a＆gt; = 0且b> = 0，则两个索引在同一个方格中。
如果两个索引在同一个方格中，并且（a / 3）==（b / 3），则它们在同一行中。
如果两个索引位于同一个方格中，并且（a％3）==（b％3），则它们位于同一列中。

Answer 2

有几种方法可以做到这一点，我选择一个奇怪的只是为了好玩。使用模数。

你的行大小为3，只需使用3的模数和两个简单的规则。

If currPos mod 3 = 0 and (currPos+move) mod 3 = 1 then invalid
If currPos mod 3 = 1 and (currPos+move) mod 3 = 0 then invalid

这个检查你跳了两个新行，你也可以做一个像这样的规则

if (currPos mod 3)-((currPos+move) mod 3)> 1 then invalid

干杯

Answer 3

你应该为此使用多维数组。

如果您的数组类不支持多维内容，那么您应该编写一个快速包装器。

确定存储为数组的正方形的有效相邻单元格

3 个答案: