如何按基数方向自由遍历二维数组中的元素？（下、上、左、右）

2024-03-02

这个问题 https://stackoverflow.com/q/22239871/2736496是关于计算穿过迷宫的路径，由二维数组表示。例如，穿过这个迷宫的路径

   0 1 2 3 4
   ---------
0| 1 0 1 1 1
1| 1 0 0 0 1
2| 1 0 1 0 1
3| 1 1 1 0 1
4| 1 1 1 0 1

START: [0,1]
Down:  [1,1]
Right: [1,2]
Right: [1,3]
Down:  [2,3]
Down:  [3,3]
Down:  [4,3]

发布者试图纯粹通过递归来做到这一点，并且实际上在五个小时内发布了四个不同的问题 - 这说明了它的复杂性。

这让我想到了一个更普遍的问题：如何在二维数组中的任意基本方向上自由移动元素？下、上、左、右

如果这个问题能够解决的话，那么穿越迷宫就容易多了。

我用两个类和一个枚举解决了这个问题。

首先，枚举，它定义要移动的方向，并根据其移动一次确定新索引。

enum Direction {
   UP(-1, 0),
   DOWN(1, 0),
   LEFT(0, -1),
   RIGHT(0, 1);

   private final int rowSteps;
   private final int colSteps;
   private Direction(int rowSteps, int colSteps)  {
      this.rowSteps = rowSteps;
      this.colSteps = colSteps;
   }
   public int getNewRowIdx(int currentRowIdx)  {
      return  (currentRowIdx + getRowSteps());
   }
   public int getNewColIdx(int currentColIdx)  {
      return  (currentColIdx + getColSteps());
   }
   public int getRowSteps()  {
      return  rowSteps;
   }
   public int getColSteps()  {
      return  colSteps;
   }
};

主类称为GridPosition（以下）。首先，通过其将双数组网格设置到其中int[][]构造函数，并静态存储该实例：

private static final GridPosition GRID_HOLDER = new GridPosition(GRID);

（这一步可以设计得更好，但它有效。而且，它应该接受任何类型。）

设置网格后（这是一次性的事情，每次执行），然后使用 x/y 构造函数来声明初始位置：

GridPosition pos = new GridPosition(0, 0);

之后，根据需要移动：

pos = pos.getNeighbor(Direction.RIGHT);
pos = pos.getNeighbor(Direction.RIGHT);
pos = pos.getNeighbor(Direction.DOWN);
...

每个位置的值通过以下方式检索pos.getValue()。（顺便说一句：用于迷宫的巨大二维数组——在这篇文章的底部，在“完整代码”中——应该真正包含一位booleans，而不是 4 字节ints, but looking数组的代码有意义ints，并且不包含布尔值...请注意，它至少应该更改为bytes.)

因此，关于移动，如果您尝试在没有邻居的情况下找到邻居，例如在左边缘向左移动，则会出现IllegalStateException被抛出。使用is*Edge()函数来避免这种情况。

GridPosition 类还有一个方便的调试功能，称为getNineByNine()，它返回数组值的 9x9 网格（作为字符串），其中中间项是当前位置。

   import  java.util.Arrays;
   import  java.util.Objects;
class GridPosition  {
//state
   private static int[][] GRID;
   private final int rowIdx;
   private final int colIdx;
//internal
   private final int rowIdxMinus1;
   private final int colIdxMinus1;
   public GridPosition(int[][] GRID)  {
      if(this.GRID != null)  {
         throw  new IllegalStateException("Grid already set. Use x/y constructor.");
      }
      GridPosition.GRID = GRID;

      //TODO: Crash if null or empty, or sub-arrays null or empty, or unequal lengths, or contain anything but 0 or -1.

      rowIdx = -1;
      colIdx = -1;
      rowIdxMinus1 = -1;
      colIdxMinus1 = -1;
   }
   public GridPosition(int rowIdx, int colIdx)  {
      if(GridPosition.GRID == null)  {
         throw  new IllegalStateException("Must set grid with: new GridPosition(int[][]).");
      }

      if(rowIdx < 0  ||  rowIdx >= GridPosition.getRowCount())  {
         throw  new IllegalArgumentException("rowIdx (" + rowIdx + ") is invalid.");
      }
      if(colIdx < 0  ||  colIdx >= GridPosition.getColumnCount())  {
         throw  new IllegalArgumentException("colIdx (" + colIdx + ") is invalid.");
      }

      this.rowIdx = rowIdx;
      this.colIdx = colIdx;
      rowIdxMinus1 = (rowIdx - 1);
      colIdxMinus1 = (colIdx - 1);
   }
   public int getValue()  {
      return  GridPosition.GRID[getRowIdx()][getColumnIdx()];
   }
   public int getRowIdx()  {
      return  rowIdx;
   }
   public int getColumnIdx()  {
      return  colIdx;
   }
   public GridPosition getNeighbor(Direction dir)  {
      Objects.requireNonNull(dir, "dir");
      return  (new GridPosition(
         dir.getNewRowIdx(getRowIdx()),
         dir.getNewColIdx(getColumnIdx())));
   }
   public GridPosition getNeighborNullIfEdge(Direction dir)  {
      if(isEdgeForDirection(dir))  {
         return  null;
      }
      return  getNeighbor(dir);
   }
   public int getNeighborValueNeg1IfEdge(Direction dir)  {
      GridPosition pos = getNeighborNullIfEdge(dir);
      return  ((pos == null) ? -1 : pos.getValue());
   }
   public static final int getRowCount()  {
      return  GRID.length;
   }
   public static final int getColumnCount()  {
      return  GRID[0].length;
   }
   public boolean isEdgeForDirection(Direction dir)  {
      Objects.requireNonNull(dir);
      switch(dir)  {
         case UP:    return isTopEdge();
         case DOWN:  return isBottomEdge();
         case LEFT:  return isLeftEdge();
         case RIGHT: return isRightEdge();
      }
      throw  new IllegalStateException(toString() + ", dir=" + dir);
   }
   public boolean isLeftEdge()  {
      return  (getColumnIdx() == 0);
   }
   public boolean isTopEdge()  {
      return  (getRowIdx() == 0);
   }
   public boolean isBottomEdge()  {
      return  (getRowIdx() == rowIdxMinus1);
   }
   public boolean isRightEdge()  {
      return  (getColumnIdx() == colIdxMinus1);
   }
   public String toString()  {
      return  "[" + getRowIdx() + "," + getColumnIdx() + "]=" + getValue();
   }
   public String getNineByNine()  {
      int[][] nineByNine = new int[3][3];

      //Middle row
         nineByNine[1][1] = getValue();
         nineByNine[1][0] = getNeighborValueNeg1IfEdge(Direction.LEFT);
         nineByNine[1][2] = getNeighborValueNeg1IfEdge(Direction.RIGHT);

      //Top
         GridPosition posUp = getNeighborNullIfEdge(Direction.UP);
         if(posUp != null)  {
            nineByNine[0][0] = posUp.getNeighborValueNeg1IfEdge(Direction.LEFT);
            nineByNine[0][1] = posUp.getValue();
            nineByNine[0][2] = posUp.getNeighborValueNeg1IfEdge(Direction.RIGHT);
         }

      //Bottom
         GridPosition posDown = getNeighborNullIfEdge(Direction.DOWN);
         if(posDown != null)  {
            nineByNine[2][0] = posDown.getNeighborValueNeg1IfEdge(Direction.LEFT);
            nineByNine[2][1] = posDown.getValue();
            nineByNine[2][2] = posDown.getNeighborValueNeg1IfEdge(Direction.RIGHT);
         }

      String sLS = System.getProperty("line.separator", "\r\n");
      return  "Middle position in 9x9 grid is *this*: " + toString() + sLS +
         Arrays.toString(nineByNine[0]) + sLS +
         Arrays.toString(nineByNine[1]) + sLS +
         Arrays.toString(nineByNine[2]);
   }
}

这是一个演示用法：

public class GridPosDemo  {
   private static final int[][] GRID = new int[][] {

   //mega grid goes here...

   };

   private static final GridPosition GRID_HOLDER = new GridPosition(GRID);

   public static final void main(String[] ignored)  {
      GridPosition pos = new GridPosition(0, 0);
      System.out.println("start: " + pos);

      pos = pos.getNeighbor(Direction.RIGHT);
      System.out.println("right: " + pos);

      pos = pos.getNeighbor(Direction.RIGHT);
      System.out.println("right: " + pos);

      pos = pos.getNeighbor(Direction.DOWN);
      System.out.println("down:  " + pos);

      pos = pos.getNeighbor(Direction.DOWN);
      System.out.println("down:  " + pos);

      pos = pos.getNeighbor(Direction.RIGHT);
      System.out.println("right: " + pos);

      pos = pos.getNeighbor(Direction.DOWN);
      System.out.println("down:  " + pos);

      pos = pos.getNeighbor(Direction.LEFT);
      System.out.println("left:  " + pos);

      pos = pos.getNeighbor(Direction.UP);
      System.out.println("up:    " + pos);

      pos = pos.getNeighbor(Direction.UP);
      System.out.println("up:    " + pos);

      System.out.println(pos.getNineByNine());
   }

}

Output

[C:\java_code\]java GridPosDemo
start: [0,0]=1
right: [0,1]=1
right: [0,2]=1
down:  [1,2]=1
down:  [2,2]=1
right: [2,3]=1
down:  [3,3]=0
left:  [3,2]=1
up:    [2,2]=1
up:    [1,2]=1
Middle position in 9x9 grid is *this*: [1,2]=1
[1, 1, 1]
[0, 1, 0]
[0, 1, 1]

为了使用它来穿过迷宫的正确路径，需要添加“碰撞检测”（这样它就不会穿过墙壁），此外还需要一些东西来跟踪你去过的地方（所以你不要最终回到起始位置）。比如与一些getNeighborIfNotWall(Direction) and isWallToLeft()功能。

抛开迷宫问题，在考虑完成这些课程之前我会做以下事情：

使数组类型变得通用，而不是整数
添加错误检查，如代码中所述
重新设计设置网格的方式。
添加对角线方向：UP_LEFT, UP_RIGHT, DOWN_LEFT, DOWN_RIGHT
添加向一个方向移动多个步骤的功能：getNeighbor(3, Direction.DOWN)

这是完整的源代码文件，包含上述所有内容（包括巨型迷宫网格）：

   //Needed only by GridPosition
   import  java.util.Arrays;
   import  java.util.Objects;

enum Direction {
   UP(-1, 0),
   DOWN(1, 0),
   LEFT(0, -1),
   RIGHT(0, 1);
//config
   private final int rowSteps;
   private final int colSteps;
   private Direction(int rowSteps, int colSteps)  {
      this.rowSteps = rowSteps;
      this.colSteps = colSteps;
   }
   public int getNewRowIdx(int currentRowIdx)  {
      return  (currentRowIdx + getRowSteps());
   }
   public int getNewColIdx(int currentColIdx)  {
      return  (currentColIdx + getColSteps());
   }
   public int getRowSteps()  {
      return  rowSteps;
   }
   public int getColSteps()  {
      return  colSteps;
   }
};

class GridPosition  {
//config
   private static int[][] GRID;
   private final int rowIdx;
   private final int colIdx;
//internal
   private final int rowIdxMinus1;
   private final int colIdxMinus1;
   public GridPosition(int[][] GRID)  {
      if(this.GRID != null)  {
         throw  new IllegalStateException("Grid already set. Use x/y constructor.");
      }
      GridPosition.GRID = GRID;

      //TODO: Crash if null or empty, or sub-arrays null or empty, or unequal lengths, or contain anything but 0 or -1.

      rowIdx = -1;
      colIdx = -1;
      rowIdxMinus1 = -1;
      colIdxMinus1 = -1;
   }
   public GridPosition(int rowIdx, int colIdx)  {
      if(GridPosition.GRID == null)  {
         throw  new IllegalStateException("Must set grid with: new GridPosition(int[][]).");
      }

      if(rowIdx < 0  ||  rowIdx >= GridPosition.getRowCount())  {
         throw  new IllegalArgumentException("rowIdx (" + rowIdx + ") is invalid.");
      }
      if(colIdx < 0  ||  colIdx >= GridPosition.getColumnCount())  {
         throw  new IllegalArgumentException("colIdx (" + colIdx + ") is invalid.");
      }

      this.rowIdx = rowIdx;
      this.colIdx = colIdx;
      rowIdxMinus1 = (rowIdx - 1);
      colIdxMinus1 = (colIdx - 1);
   }
   public int getValue()  {
      return  GridPosition.GRID[getRowIdx()][getColumnIdx()];
   }
   public int getRowIdx()  {
      return  rowIdx;
   }
   public int getColumnIdx()  {
      return  colIdx;
   }
   public GridPosition getNeighbor(Direction dir)  {
      Objects.requireNonNull(dir, "dir");
      return  (new GridPosition(
         dir.getNewRowIdx(getRowIdx()),
         dir.getNewColIdx(getColumnIdx())));
   }
   public GridPosition getNeighborNullIfEdge(Direction dir)  {
      if(isEdgeForDirection(dir))  {
         return  null;
      }
      return  getNeighbor(dir);
   }
   public int getNeighborValueNeg1IfEdge(Direction dir)  {
      GridPosition pos = getNeighborNullIfEdge(dir);
      return  ((pos == null) ? -1 : pos.getValue());
   }
   public static final int getRowCount()  {
      return  GRID.length;
   }
   public static final int getColumnCount()  {
      return  GRID[0].length;
   }
   public boolean isEdgeForDirection(Direction dir)  {
      Objects.requireNonNull(dir);
      switch(dir)  {
         case UP:    return isTopEdge();
         case DOWN:  return isBottomEdge();
         case LEFT:  return isLeftEdge();
         case RIGHT: return isRightEdge();
      }
      throw  new IllegalStateException(toString() + ", dir=" + dir);
   }
   public boolean isLeftEdge()  {
      return  (getColumnIdx() == 0);
   }
   public boolean isTopEdge()  {
      return  (getRowIdx() == 0);
   }
   public boolean isBottomEdge()  {
      return  (getRowIdx() == rowIdxMinus1);
   }
   public boolean isRightEdge()  {
      return  (getColumnIdx() == colIdxMinus1);
   }
   public String toString()  {
      return  "[" + getRowIdx() + "," + getColumnIdx() + "]=" + getValue();
   }
   public String getNineByNine()  {
      int[][] nineByNine = new int[3][3];

      //Middle row
         nineByNine[1][1] = getValue();
         nineByNine[1][0] = getNeighborValueNeg1IfEdge(Direction.LEFT);
         nineByNine[1][2] = getNeighborValueNeg1IfEdge(Direction.RIGHT);

      //Top
         GridPosition posUp = getNeighborNullIfEdge(Direction.UP);
         if(posUp != null)  {
            nineByNine[0][0] = posUp.getNeighborValueNeg1IfEdge(Direction.LEFT);
            nineByNine[0][1] = posUp.getValue();
            nineByNine[0][2] = posUp.getNeighborValueNeg1IfEdge(Direction.RIGHT);
         }

      //Bottom
         GridPosition posDown = getNeighborNullIfEdge(Direction.DOWN);
         if(posDown != null)  {
            nineByNine[2][0] = posDown.getNeighborValueNeg1IfEdge(Direction.LEFT);
            nineByNine[2][1] = posDown.getValue();
            nineByNine[2][2] = posDown.getNeighborValueNeg1IfEdge(Direction.RIGHT);
         }

      String sLS = System.getProperty("line.separator", "\r\n");
      return  "Middle position in 9x9 grid is *this*: " + toString() + sLS +
         Arrays.toString(nineByNine[0]) + sLS +
         Arrays.toString(nineByNine[1]) + sLS +
         Arrays.toString(nineByNine[2]);
   }
}
public class GridPosDemo  {
   private static final int[][] GRID = new int[][] {
      {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
      {0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1},
      {1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,1,1,0,1,1,1,1,1,1,1,0,1,1,1,0,1,0,1},
      {1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,1,0,1},
      {1,0,1,0,1,1,1,0,1,0,1,1,1,1,1,1,1,1,1,0,1,0,1,1,1,0,1,0,1,1,1,1,1,0,1,1,1,0,1,0,1,0,1,1,1,0,1,1,1,0,1},
      {1,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,1,0,1,0,1,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,1},
      {1,0,1,1,1,0,1,0,1,1,1,0,1,0,1,0,1,0,1,1,1,1,1,0,1,0,1,0,1,1,1,0,1,1,1,0,1,1,1,0,1,1,1,1,1,1,1,0,1,0,1},
      {1,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,1},
      {1,1,1,0,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,0,1,0,1,1,1,0,1,1,1,1,1,1,1,0,1,0,1,0,1,1,1,0,1,1,1,1,1,1,1,0,1},
      {1,0,1,0,1,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,1},
      {1,0,1,0,1,0,1,1,1,1,1,0,1,0,1,0,1,1,1,0,1,1,1,0,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,0,1,1,1,0,1,0,1,1,1},
      {1,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1},
      {1,0,1,0,1,1,1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,0,1,0,1,0,1,1,1,0,1,1,1,0,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1},
      {1,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1},
      {1,0,1,0,1,0,1,0,1,0,1,1,1,0,1,0,1,1,1,1,1,1,1,1,1,0,1,0,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,0,1,1,1,1,1,0,1},
      {1,0,0,0,1,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,1,0,0,0,0,0,1},
      {1,0,1,1,1,0,1,0,1,1,1,1,1,1,1,0,1,0,1,1,1,1,1,0,1,1,1,1,1,0,1,0,1,0,1,1,1,0,1,0,1,1,1,1,1,0,1,1,1,0,1},
      {1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,1},
      {1,1,1,1,1,0,1,1,1,0,1,1,1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,0,1,0,1,1,1,1,1,0,1,0,1,0,1,0,1,1,1,1,1,0,1,0,1},
      {1,0,0,0,1,0,0,0,1,0,0,0,1,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,1},
      {1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,0,1,0,1,1,1,0,1,0,1,1,1,0,1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,0,1,0,1,0,1,0,1},
      {1,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,1,0,1,0,1,0,1},
      {1,1,1,0,1,0,1,1,1,0,1,1,1,0,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,0,1,0,1,0,1,1,1,0,1,0,1,0,1,0,1,0,1,1,1,0,1},
      {1,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,1},
      {1,0,1,1,1,0,1,0,1,1,1,0,1,1,1,0,1,1,1,1,1,1,1,0,1,1,1,0,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,0,1,0,1},
      {1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1},
      {1,0,1,1,1,1,1,1,1,0,1,1,1,0,1,1,1,0,1,0,1,0,1,0,1,0,1,1,1,0,1,0,1,0,1,1,1,1,1,0,1,0,1,1,1,0,1,0,1,0,1},
      {1,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,1,0,0,0,1,0,1,0,1},
      {1,0,1,1,1,1,1,0,1,0,1,0,1,0,1,0,1,1,1,0,1,0,1,0,1,0,1,1,1,1,1,0,1,0,1,0,1,1,1,0,1,0,1,0,1,1,1,1,1,0,1},
      {1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,1,0,0,0,1,0,1,0,0,0,0,0,1,0,1},
      {1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,0,1},
      {1,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,1,0,1},
      {1,0,1,1,1,0,1,1,1,0,1,0,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,0,1,0,1,0,1,0,1},
      {1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1},
      {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1}};
   private static final GridPosition GRID_HOLDER = new GridPosition(GRID);

   public static final void main(String[] ignored)  {
      GridPosition pos = new GridPosition(0, 0);
      System.out.println("start: " + pos);

      pos = pos.getNeighbor(Direction.RIGHT);
      System.out.println("right: " + pos);

      pos = pos.getNeighbor(Direction.RIGHT);
      System.out.println("right: " + pos);

      pos = pos.getNeighbor(Direction.DOWN);
      System.out.println("down:  " + pos);

      pos = pos.getNeighbor(Direction.DOWN);
      System.out.println("down:  " + pos);

      pos = pos.getNeighbor(Direction.RIGHT);
      System.out.println("right: " + pos);

      pos = pos.getNeighbor(Direction.DOWN);
      System.out.println("down:  " + pos);

      pos = pos.getNeighbor(Direction.LEFT);
      System.out.println("left:  " + pos);

      pos = pos.getNeighbor(Direction.UP);
      System.out.println("up:    " + pos);

      pos = pos.getNeighbor(Direction.UP);
      System.out.println("up:    " + pos);

      System.out.println(pos.getNineByNine());
   }

}

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

如何按基数方向自由遍历二维数组中的元素？（下、上、左、右）的相关文章

Java 弱哈希映射 - 需要根据值的弱点而不是键来删除条目

所以JavaWeakHashMap让我们创建一个映射如果其键变弱则删除该映射的条目但是我怎样才能创建一个Map 当它的条目被删除时values地图上变弱了我想使用映射的原因是作为全局哈希表它根据对象的 ID 跟踪对象 ID gt
如何用Java创建图像

比如说在我的程序中我有这个paint 方法我的愿望是创建所绘制的矩形的图像使用 for 循环我尝试了下面的方法它确实给了我那些矩形蓝色但背景是全黑的当我运行程序而不创建图像仅在 JFrame 上绘制矩形时背景为白色我怎
可以向 @ManyToMany Hibernate 额外表添加额外字段吗？

我有这两类表 Entity Table name course public class Course Id Column name courseid private String courseId Column name coursen
从继承的受保护 Java 字段创建公共访问器

我怎样才能完成以下工作 class Foo extends javax swing undo UndoManager increase visibility works for method override def editToBeUnd
为什么 MetaSpace 大小是已用 MetaSpace 的两倍？

我写了一个程序来模拟MetaSpace OOM 但我发现MetaSpace Size几乎总是两倍大Used MetaSpace Why 我用标志运行我的程序 XX MaxMetaspaceSize 50m 程序抛出OOM时Used Meta
将二进制数据的 byte[] 转换为 String

我有二进制格式的数据 hex 80 3b c8 87 0a 89 我需要将其转换为字符串以便通过 Jackcess 将二进制数据保存在 MS Access 数据库中我知道我不打算在 Java 中使用 String 来存储二进制数据但
在 JSP 中对表单操作使用相对路径

如何在表单操作中使用相对路径
Java 将字节转换为二进制安全字符串

我有一些以字节为单位的数据我想将它们放入Redis中但是Redis只接受二进制安全字符串而我的数据有一些二进制非安全字节那么如何将这些字节转换为二进制安全字符串以便将它们保存到 Redis 中呢 Base64 对我有用但它使数据更
将 emoji 替换为适当的 java 代码

我正在开发一个简单的java程序它可以接受这样的字符串停止你违反了法律但是现在你并将每个表情符号替换为适当的 java 字符我不知道该怎么称呼他们这是一个例子汽车表情符号将替换为 uD83D uDE97 这允许我有一个
可以混合使用 JVM 语言吗？即：Groovy 和 Clojure

我知道你可以轻松地混合groovy java clojure java 无论什么JvmLang java 这是否也意味着我也可以让 clojure 和 groovy 代码进行交互如果我使用 Grails 或 jRoR 我也可以在该环境中使
从 org.w3c.dom.Node 获取 Xpath

我可以从 org w3c dom Node 获取完整的 xpath 吗假设当前节点指向 xml 文档中间的某个位置我想提取该元素的 xpath 我正在寻找的输出 xpath 是 parent child1 chiild2 child3
Keycloak 社交登录 REST API

我已经为我的 keycloak 实例启用了谷歌社交登录但我需要将其用作休息服务是否有可用于执行此操作的端点 Keycloak 中没有 Google 身份验证 API 但您可以使用以下方法解决它代币交换 https www keycloa
C# datagridview 列转入数组

我正在用 C 构建一个程序并在其中包含一个 datagridview 组件 datagridview 有固定数量的列 2 我想将其保存到两个单独的数组中但行数确实发生了变化我怎么能这样做呢假设一个名为 dataGridView1 的
指向字节数组的指针

由于 Misra C 的要求我的一位同事想要使用指针声明但我遇到了一些问题 Misra 安全关键指南不会让我们纯粹的程序员使用指针但会让我们对数组字节进行操作他打算获取一个指向字节数组的指针因此我们不会在堆栈上传递实际的数组 T
使用antlr4获取预处理器行并解析C代码

我正在使用 Antlr4 来解析 C 代码并使用以下语法来解析链接到 C g4 https github com antlr grammars v4 blob master c C g4 上面的语法默认不提供任何解析规则来获取预处理器语
JSP 作为电子邮件模板

有没有办法发送 MIME 电子邮件其中电子邮件正文源自 JSP 我需要使用 Javamail 发送一封电子邮件其中包含一个表格我认为如果我可以使用 JSP 来完成所有格式设置和布局将会很方便在这个线程中 Java 电子邮件模板的建
Android - 保持用户登录状态

我正在尝试使用 PHP 和 MySQLi for Android 进行登录我不明白的是如何保持用户登录状态我看到一个简单的教程其中有人使用 SQLite 来保护信息但我不知道这是否真的安全如何保存用户信息以保持用户登录状态谢谢
Android应用程序中的模式输入

我想知道是否有其他替代方案可以替代 Android 上平庸的 EditText 密码输入是否有 API 或开源代码可以集成到我的应用程序中类似于锁屏图案解锁 Intent 可能会返回哈希值数字字符串或代表用户输入的模式的任何内容我
如果所有类不在同一个包中，Spring @autowired 不起作用

我有四个包裹 com spring org Files HomeController java com spring org dao Files SubscriberDao java SubscriberDaoImpl java com s
按字母顺序对对象的 ArrayList 进行排序

我必须创建一个方法来排序数组列表根据电子邮件按字母顺序排列对象然后打印排序后的数组我在排序时遇到麻烦的部分我已经研究过并尝试使用Collections sort vehiclearray 但这对我不起作用我是因为我需要一个叫做比较器

随机推荐

有没有办法对VBA中的代码施加时间限制？

我想知道是否有人有对代码段施加时间限制的经验我已经用 VBA 将搜索引擎编程到 Excel 电子表格中并且有一段代码可以删除重复的结果现在如果给出最模糊的搜索条件这部分有时可能会持续相当长的时间所以我想对这个操作施加一个时间限制
使用滑块更改 QTimer 的间隔超时

timer new QTimer this timer gt setInterval 50 QPushButton start new QPushButton Start Stop this start gt setText Start S
使用 Core Data（在 SwiftUI 中）提供的数据并与另一个视图共享

我在这里遇到了一些麻烦Core Data and SwiftUI 我的主视图可以访问来自实体的一些信息Core Data 我想使用某种绑定将其传递给子视图以便它也可以访问该数据并可能更新它这是我尝试过的代码的一个版本在主视图一侧 En
如何在此 React 18 应用程序中即时验证表单字段？

我正在使用 React 18 和 Firebase 开发一个聊天应用程序 In the src pages Register jsx组件我有一个可以验证的表单简单的身体验证器 https github com jadKhoury1 sim
如何在组织模式下使用其他标题样式，例如 twiki ---+ 或 mediawiki == h2 == ？

我真的很想使用组织模式但是我想使用 org mode 来理解已经使用不同标题语法编写的结构化文档例如使用 twiki 的 H1 Top level H2 Nested H1 2 Second top level 或者类似媒体维基 H1
将内存映射与服务一起使用

我构建了一个也可以作为服务运行的应用程序使用 service 转变当我从命令提示符运行服务时这可以完美地工作没有任何问题我设置了一些设置可以让我在不作为真正的服务运行时从控制台调试它但是当我尝试将其作为真正的服务运行然后使用
Windows终端：打开多个窗格并执行指定命令

我最近下载了新的Windows Terminal 我已经创建了用于打开多个窗格的快捷方式工作正常但是我正在尝试为相应的窗格执行命令 wt d
简单的 PHP 函数从文本文件中删除最后一行不起作用

我有一个名为test只有 2 行 1 2 我希望能够从文件中删除最后一行因此我使用以下函数由于某种原因这没有任何作用并且文件仍然具有确切的行我在这里遗漏了一些东西吗 file http php net manual en func
在使用和不使用推送调用的情况下对 UFBV 上的 Z3 进行增量调用

我正在 UFBV 查询上运行 Z3 目前查询包含2个调用check sat 如果我把push 1刚过check sat Z3在30秒内解决了查询如果我不放任何push 1根本没有因此有两个电话check sat没有任何push 1他们之
如何在Powershell中按字符串拆分字符串

我试图用分隔符吐出字符串它是一个字符串 string 5637144576 messag lt gt est lt lt gt gt 5637145326 1 lt lt gt gt 5637145328 0 separator lt l
如何使用 WebDriver (Selenium 2) 检查 dom 是否有一个类？

我对 Selenium 很陌生所以如果这是一个愚蠢的问题我很抱歉我已成功将 IntelliJ Play 框架与 Selenium 连接起来并使用 firefoxDrivers 创建了一些测试我正在尝试检查该页面是否已正确验证长
java.lang.OutOfMemoryError：将 13k .png 图像拼接在一起时的 Java 堆空间

我有 13255 张图像每张图像宽度为 240 x 240 像素最大大小为 15 412 字节最小大小为 839 字节我试图循环遍历文件夹将它们添加到 File 中一旦我有了每个图像的数组我就将它们放入 BufferedIma
高效使用 Visual Studio diff 编辑器

我正在使用 Visual Studio 2015 并且有一个使用 Git 在本地进行版本控制的项目当我双击团队资源管理器窗口中的文件时将打开一个 Diff 编辑器在其他 IDE Eclipse IntelliJ 中我习惯于在这些
如何在svn中将文件夹切换到符号链接

我有一个文件夹它是 svn 中一个项目的一部分已被移动到另一个文件夹存储库以在项目之间共享我想用符号链接替换 svn 中的这个目录但是当我尝试这样做时我收到以下消息 svn Entry project wwwdocs js ha
负载测试时如何测量CPU和内存

我们在异构环境中使用 JMeter 并且希望在运行服务或 Web 应用程序的服务器上产生重负载时测量 CPU 和内存您建议使用什么是否有任何软件解决方案开源或商业可以将 CPU 和内存使用情况记录在文件或数据库中谢谢你您可以使用
将其他实体添加到实体框架支持的域服务

我们正在研究使用 RIA 服务 7 月 9 日预览版来公开现有 EF 模型的部分内容我们已向 Web 应用程序添加了一个域服务类并指定了要使用的 EF 模型并选择了一些我们希望通过域服务提供的实体有些已启用编辑大多数没有我们构
为散点图中的每个点绘制词云

我创建了一个根据以下数据定义的散点图请注意当前仅使用前两个字段进行绘图 var data 5 3 text word1 size 4 text word2 size 1 3 5 text word3 size 5 text word4
解码 NSString 中的 Base-64 编码 PNG

我有一些NSData它是 Base 64 编码的我想解码它我看到了一个如下所示的示例 NSData myPNGData xmlString dataUsingEncoding NSUTF8StringEncoding Base64 in
如何使用 django 重定向功能传递上下文数据？

我有重定向到 URL 的函数 return redirect orders The URL orders有一些正在传递给它的上下文数据我想传递一些额外的数据以及来自 URL 函数的数据如下所示 return redirect order
如何按基数方向自由遍历二维数组中的元素？（下、上、左、右）

这个问题 https stackoverflow com q 22239871 2736496是关于计算穿过迷宫的路径由二维数组表示例如穿过这个迷宫的路径 0 1 2 3 4 0 1 0 1 1 1 1 1 0 0 0 1 2 1 0

如何按基数方向自由遍历二维数组中的元素？ （下、上、左、右）

如何按基数方向自由遍历二维数组中的元素？ （下、上、左、右） 的相关文章

随机推荐

热门标签

如何按基数方向自由遍历二维数组中的元素？（下、上、左、右）

如何按基数方向自由遍历二维数组中的元素？（下、上、左、右）的相关文章