用于游戏的Java 2D数组对角线。

To clarify I only wanted one or two for loops to help me on my way, preferably in the same style as I had used in the vertical :)

为了澄清这一点，我只想要一两个for循环来帮助我，最好采用我在垂直方向上使用过的风格:)

I'm making a game using a 2D array, and I need a check that tests if at the current position (indicated by a green square) the character there is part of a diagonal sequence of "l" more of the character.

我正在用一个2D数组做一个游戏，我需要一个检查，以测试在当前位置(由一个绿色方块表示)是否存在一个“l”字符的对角线序列的一部分。

2 个解决方案

#1

public static boolean diagonals(char[][] b, int row, int col, int l) {

            int counter = 1; // because we start from the current position
            char charAtPosition = b[row][col];
            int numRows = b.length;
            int numCols = b[0].length;
            int topleft = 0;
            int topright = 0;
            int bottomleft = 0;
            int bottomright = 0;
            for (int i=row-1,j=col-1;i>=0 && j>=0;i--,j--) {
                if (b[i][j]==charAtPosition) {
                    topleft++;
                } else {
                    break;
                }
            }
            for (int i=row-1,j=col+1;i>=0 && j<=numCols;i--,j++) {
                if (b[i][j]==charAtPosition) {
                    topright++;
                } else {
                    break;
                }
            }
            for (int i=row+1,j=col-1;i<=numRows && j>=0;i++,j--) {
                if (b[i][j]==charAtPosition) {
                    bottomleft++;
                } else {
                    break;
                }
            }
            for (int i=row+1,j=col+1;i<=numRows && j<=numCols;i++,j++) {
                if (b[i][j]==charAtPosition) {
                    bottomright++;
                } else {
                    break;
                }
            }
            return topleft + bottomright + 1 >= l || topright + bottomleft + 1 >= l; //in this case l is 5
    }

The idea is that we walk in four directions and count the steps. This may not be the most efficient implementation, but at least it looks neat and easy to understand.

我们的想法是沿着四个方向走，然后数台阶。这可能不是最有效的实现，但至少看起来很整洁，很容易理解。

#2

Here's the function, it works. The explanation is in the comments in the code, but if you find anything confusing let me know and I'll explain it.

这是函数，它是有效的。解释在代码的注释中，但是如果你发现有什么让人困惑的地方，请告诉我，我会解释的。

public static boolean diagonals(char[][] b, int row, int col, int l) {
  int forwardCounter = 1; // this counts top right to bottom left
  int backCounter = 1; // this counts top left to bottom right
  int distance = 1;
  // 0 = topleft, 1 = topright, 2 = bottomleft, 3 = bottomright
  boolean[] checks = new boolean[]{true, true, true, true};

  char charAtPosition = b[row][col];

  while(checks[0] || checks[1] || checks[2] || checks[3]) {
    for(int i = 0; i < 4; i++) {
      if(checks[i]) {
        // This looks confusing but it's simply just converting i into
        // The four different directions
        checks[i] = checkSquare(b, row + (i < 2 ? -distance : distance),
                col + (i % 2 == 0 ? -distance : distance), charAtPosition);
        if(checks[i]) {
          // If top left or bottom right
          if(i % 3 == 0) {
            backCounter++;
          } else {
            forwardCounter++;
          }
        }
      }
    }

    if (forwardCounter >= l || backCounter >= l) return true;

    distance++;
  }

  return false;
}

private static boolean checkSquare(char[][] b, int row, int col, char check) {
  if(row < 0 || row >= b.length) return false;
  if(col < 0 || col >= b[0].length) return false;

  return check == b[row][col];
}