Java 如何获得数独2D数组索引，给定它的；“次电网”；及；“子网格中的单元格”；索引？

我正在做一个数独游戏，但我很难减少其中的一部分

我正在设计一个

SudokuBoard

对象，使其具有一个底层的2D字节数组，以及该数组的三种不同视图：行单元、列单元和网格单元。网格是九乘九的块，索引如下：

        GRID INDEX

        |         |
   0    |    1    |    2
        |         |
 -------------------------
        |         |
   3    |    4    |    5
        |         |
 -------------------------
        |         |
   6    |    7    |    8
        |         |

每个网格有九个单元格，索引如下

CELL INDEX

   0 1 2
   3 4 5
   6 7 8

以下是电路板的二维阵列坐标：

                    2D-ARRAY COORDINATE

[0,0] [0,1] [0,2]  |  [0,3] [0,4] [0,5]  |  [0,6] [0,7] [0,8]
[1,0] [1,1] [1,2]  |  [1,3] [1,4] [1,5]  |  [1,6] [1,7] [1,8]
[2,0] [2,1] [2,2]  |  [2,3] [2,4] [2,5]  |  [2,6] [2,7] [2,8]
-------------------+---------------------+-------------------
[3,0] [3,1] [3,2]  |  [3,3] [3,4] [3,5]  |  [3,6] [3,7] [3,8]
[4,0] [4,1] [4,2]  |  [4,3] [4,4] [4,5]  |  [4,6] [4,7] [4,8]
[5,0] [5,1] [5,2]  |  [5,3] [5,4] [5,5]  |  [5,6] [5,7] [5,8]
-------------------+---------------------+-------------------
[6,0] [6,1] [6,2]  |  [6,3] [6,4] [6,5]  |  [6,6] [6,7] [6,8]
[7,0] [7,1] [7,2]  |  [7,3] [7,4] [7,5]  |  [7,6] [7,7] [7,8]
[8,0] [8,1] [8,2]  |  [8,3] [8,4] [8,5]  |  [8,6] [8,7] [8,8]

我创建了一个函数来获取数组坐标，给定网格和单元格索引。确定列索引是一个脑筋急转弯，但我发现是的

int colIdx = (cell_idx % 3) + ((grid_idx % 3) * 3);

我还发现了确定行索引的方法，但我不满意这有多复杂

int rowIdx = -1;
if(grid_idx < 3)  {
   rowIdx = ((cell_idx < 3) ? 0
      :  ((cell_idx < 6) ? 1 : 2));
}  else if(grid_idx < 6)  {
   rowIdx = ((cell_idx < 3) ? 3
      :  ((cell_idx < 6) ? 4 : 5));
}  else  {
   rowIdx = ((cell_idx < 3) ? 6
      :  ((cell_idx < 6) ? 7 : 8));
}

introwidx=-1；
如果（网格_idx<3）{
rowIdx=（（单元格_idx<3）？0
：（（cell_idx<6）？1:2））；
}else if（网格_idx<6）{
rowIdx=（（单元格_idx<3）？3
：（（cell_idx<6）？4:5））；
}否则{
rowIdx=（（单元格_idx<3）？6
：（（cell_idx<6）？7:8））；
}

如果有人能想到如何把它简化成一个数学公式，我将不胜感激

这里有一个正在运行的应用程序来演示它。谢谢你的帮助

  import  java.util.Arrays;
/**
   <P>{@code SudokuGridUnitCoordinates}</P>
 **/
public class SudokuGridUnitCoordinates  {
   public static final void main(String[] idxZeroGridIdx_0to8)  {
     int gridIdx = -1;
     try  {
        gridIdx = Integer.parseInt(idxZeroGridIdx_0to8[0]);
        if(gridIdx < 0  ||  gridIdx > 8)  {
           throw  new IllegalArgumentException();
        }
     }  catch(IllegalArgumentException | ArrayIndexOutOfBoundsException  x)  {
        throw  new IllegalArgumentException("The first element in idxZeroGridIdx_0to8 must be a digit zero through 8: " + Arrays.toString(idxZeroGridIdx_0to8));
     }

     printCellCoordinates(gridIdx, 0);
     printCellCoordinates(gridIdx, 1);
     printCellCoordinates(gridIdx, 2);
     printCellCoordinates(gridIdx, 3);
     printCellCoordinates(gridIdx, 4);
     printCellCoordinates(gridIdx, 5);
     printCellCoordinates(gridIdx, 6);
     printCellCoordinates(gridIdx, 7);
     printCellCoordinates(gridIdx, 8);
  }
  private static final void printCellCoordinates(int grid_idx, int cell_idx)  {
     int rowIdx = -1;
     if(grid_idx < 3)  {
        rowIdx = ((cell_idx < 3) ? 0
           :  ((cell_idx < 6) ? 1 : 2));
     }  else if(grid_idx < 6)  {
        rowIdx = ((cell_idx < 3) ? 3
           :  ((cell_idx < 6) ? 4 : 5));
     }  else  {
        rowIdx = ((cell_idx < 3) ? 6
           :  ((cell_idx < 6) ? 7 : 8));
     }
     int colIdx = (cell_idx % 3) + ((grid_idx % 3) * 3);

     System.out.println("grid=" + grid_idx + ", cell=" + cell_idx + " --> sudoku2DGridArray[" + rowIdx + ", " + colIdx + "]");
  }
}

导入java.util.array；
/**
 {@code SudokuGridUnitCoordinates}
**/
公共类sudokugridunit坐标{
公共静态最终void main（字符串[]idxZeroGridIdx_0to8）{
int gridIdx=-1；
试一试{
gridIdx=Integer.parseInt（idxZeroGridIdx_0to8[0]）；
if（gridIdx<0 | | gridIdx>8）{
抛出新的IllegalArgumentException（）；
}
}catch（IllegalArgumentException | ArrayIndexOutOfBoundsException x）{
抛出新的IllegalArgumentException（“idxZeroGridIdx_0to8中的第一个元素必须是数字0到8:“+Arrays.toString（idxZeroGridIdx_0to8））；
}
打印单元坐标（gridIdx，0）；
打印单元坐标（gridIdx，1）；
打印单元坐标（gridIdx，2）；
打印单元坐标（gridIdx，3）；
打印单元坐标（gridIdx，4）；
打印单元坐标（gridIdx，5）；
打印单元坐标（gridIdx，6）；
打印单元坐标（gridIdx，7）；
打印单元坐标（gridIdx，8）；
}
专用静态最终空打印单元坐标（int grid_idx，int cell_idx）{
int rowIdx=-1；
如果（网格_idx<3）{
rowIdx=（（单元格_idx<3）？0
：（（cell_idx<6）？1:2））；
}else if（网格_idx<6）{
rowIdx=（（单元格_idx<3）？3
：（（cell_idx<6）？4:5））；
}否则{
rowIdx=（（单元格_idx<3）？6
：（（cell_idx<6）？7:8））；
}
int colIdx=（单元idx%3）+（网格idx%3）*3）；
System.out.println（“grid=“+grid_idx+”，cell=“+cell_idx+”-->sudoku2DGridArray[“+rowIdx+”，“+colIdx+”””）；
}
}

包含所有

？：

操作符的块就是

网格idx-网格idx%3+单元格idx/3

包含所有

？：

操作符的块就是

网格idx-网格idx%3+单元格idx/3

那怎么办

rowIdx = 3*(grid_idx/3) + cell_idx/3

所有除法都是整数除法

那怎么办

rowIdx = 3*(grid_idx/3) + cell_idx/3

---

所有除法都是整数除法

谢谢。效果很好。老实说，@DavidWallace的回答稍微干净了一点，但我会在这里支持失败者：）谢谢。我很想知道你是如何发现它“更干净”的？如果我能提供一个可能的线索-我在这个解决方案和我发布的解决方案之间抛出，因为两者都很好。我决定使用

%

和

-

可能比

/

和

*

稍微有效一些，尽管我想这取决于处理器架构。我可能错了，但这正是我的原因。请注意，如果编写

grid\u idx/3*3+cell\u idx/3

，可以避免使用括号，因为

*

和

/

从左到右关联。Cleaner是错误的单词。如果我有你们两位的数学经验/知识，这就更接近我自己可能写的东西了。虽然我真的不知道该怎么说，但你的工资似乎还可以进一步减少。例如，为什么不能将

（3*（grid\u idx/3）

简化为

grid\u idx

（因为3*5/3当然是5）。但我试过了，但它不起作用。这不是抱怨，因为你的答案完美无瑕（我向你疯狂的数学技能低头），但这正是我想说的。好吧，

3*5/3

和

3*（5/3）

不是一回事。一个是5，另一个是3。谢谢。效果很好。老实说，@DavidWallace的答案有点干净，但我会在这里支持失败者：）谢谢。我很想知道你是如何发现它“更干净”的？如果我能提供一个可能的线索-我在这个解决方案和我发布的解决方案之间抛出，因为两者都很好。我决定使用

%

和

-

可能比

/

和

*

稍微有效一些，尽管我想这取决于处理器架构。我可能错了，但这正是我的原因。请注意，如果编写

grid\u idx/3*3+cell\u idx/3

，可以避免使用括号，因为

*

和

/

从左到右关联。Cleaner是错误的单词。如果我有你们两位的数学经验/知识，这就更接近我自己可能写的东西了。虽然我真的不知道该怎么说，但你的工资似乎还可以进一步减少。例如，为什么不能将

（3*（grid\u idx/3）

简化为

grid\u idx

（因为3*5/3当然是5）。但我试过了，但它不起作用。这不是抱怨，因为你的答案完美无瑕（我向你疯狂的数学技能低头），但这只是一个突出的问题。嗯，

3*5/3

和

3*（5/3）

不是一回事。一个是5，另一个是3。