Question

我有一个阵列，打印时，这样打印：

    W V E R T I C A L L 

    R O O A F F L S A B 

    A C R I L I A T O A 

    N D O D K O N W D C 

    D R K E S O O D D K 

    O E E P Z E G L I W 

    M S I I H O A E R A 

    A L R K R R I R E R 

    K O D I D E D R C D 

    H E L W S L E U T H

如何让它像这样打印：

    # # # # # # # # # # # #

    # W V E R T I C A L L #

    # R O O A F F L S A B #

    # A C R I L I A T O A #

    # N D O D K O N W D C #

    # D R K E S O O D D K #

    # O E E P Z E G L I W #

    # M S I I H O A E R A #

    # A L R K R R I R E R #

    # K O D I D E D R C D #

    # H E L W S L E U T H #

    # # # # # # # # # # # #

我已经尝试将尺寸设置得更大以适应额外的角色，但我不断超出范围。我基本上试图得到一个非字母字符来围绕我的数组创建一个边框，这样当我实现我的填字游戏解算器时，在搜索周围字母中的字母时，它不会触及边界，而是会触及非字母字符然后传递假。

这是构建我的数组的代码：

    for (int i=1; i<row; i++){
        String getChar = (new String(sc.next()));
        for(int j = 1;j<col; j++){
            puzzle[i][j] = getChar.charAt(j);
            }
        }

感谢任何帮助！

编辑：打印我的数组：

     for (int i=0; i<puzzle.length; i++){

           System.out.print(Arrays.toString(puzzle[i]));
           System.out.println("");
     }

EDIT2：这是我的检查方法：

    private static boolean checkNE(int row, int col, String word, char[][] puzzle) {
    //Checking diagonals direction
    for(int letter = 1; letter < word.length(); letter++) {
        if(puzzle[row - letter][col + letter] != word.charAt(letter)) {
            return false;
        }
    }
    return true;
}

Answer 1

而不是制作边框，只需检查您要检查的位置是否在数组之外，如果是，那么您知道您将无法找到整个单词，因为我们必须去外面数组。

例如，您的数组是n x n，如果您尝试访问位置n，那么它将超出范围，或者如果您尝试访问小于0的位置它也将超出范围。所以，只要确保你在这个范围内访问它。

Answer 2

您可能应该使用类或边界检查，但这里是如何做您想做的事情。假设您的填字游戏是row行和col列，则需要拼图为char[row+2][col+2]类型。

String getChar = '';
for (int i=0; i<row+2; i++){
    if (i > 0 && i < row +1) {
       getChar = (new String(sc.next()));
    }
    for(int j = 0;j<col+2; j++){
        if (i % (row + 1) == 0 || i % (col + 1) == 0) {
            puzzle[i][j] = '#';
        else {
            puzzle[i][j] = getChar.charAt(j-1);
        }
    }
}

如果您想查看它的实际效果，请查看here on ideone.com。

您询问是否使用row和col预先增加，它看起来像这样：

for (int i=0; i<row; i++){
    if (i > 0 && i < row +1) {
       getChar = (new String(sc.next()));
    }
    for(int j = 0;j<col; j++){
        if (i % (row - 1) == 0 || j % (col - 1) == 0) {
            puzzle2[i][j] = '#';
        } else {
            puzzle2[i][j] = getChar.charAt(j-1);
        }
    }
}

Answer 3

for (int i=1; i<row; i++){
    String getChar = (new String(sc.next()));
    for(int j = 1;j<col; j++){
        puzzle[i][j] = getChar.charAt(j);
    }
}

顺便说一句：请记住，Java中的索引从0（而不是1）开始。在您的示例中，您将从1到最大列长度进行迭代，这就是您可以获得IndexOutOfBoundsException

的原因

Answer 4

我不是Java程序员，但我认为Java数组索引从零开始，就像C一样。所以，如果你把拼图设为10x10，然后尝试访问拼图[1] [10]，你会得到一个“异常：越界”错误。也就是说，拼图不是从拼图[1] [1]到拼图[10] [10]。它从拼图[0] [0]到拼图[9] [9]。如果这不正确，Java程序员请更正。

Answer 5

您需要使用嵌套循环。 Firstable你没有在当前代码中打印任何东西，比如数组索引的开头是1，那样你就永远不会把任何东西放到索引为0的第一个元素上。

public class BorderArray {
  public static void main(String[] args) {
    // Setup the puzzle, this may change or use input.
    //Assert that this string is 100 size length or row/col will not work.
    String chars = "WVERTICALLROOAFFLSABACRILIATOANDODKONWDCDRKESOODDKOEEPZEGLIWMSIIHOAERAALRKRRIRERKODIDEDRCDHELWSLEUTH";
    int row = 10, col = 10;
    char puzzle[][] = new char[row][col];
    for (int i = 0; i < row; i++) {
      for (int j = 0; j < col; j++) {
        puzzle[i][j] = chars.charAt(i + j);
      }
    }
    // You print the top border.
    // # # # # # # # # # # # # ... print '#' col+2 times
    for (int j = 0; j <= col; j++) {
      System.out.print("# "); // inline
    }
    System.out.println("# "); // move to next line

    // # W V E R T I C A L L # ... print '#' before and after the characters of the row
    // start i at 0 since arrays start at 0
    for (int i = 0; i < row; i++) {
      // for every row print chars of every column inline
      System.out.print("# "); // before
      for (int j = 0; j < col; j++) {
        System.out.print(puzzle[i][j] + " "); // print every char
      }
      System.out.println("#"); // after and next line
    }

    // Bottom border
    // # # # # # # # # # # # # ... print '#' col+2 times, you don't need new line since this is the end.
    // Just use col+1 as limit of the loop.
    for (int j = 0; j <= col + 1; j++) {
      System.out.print("# ");
    }

  }
}

Answer 6

简单，不要将其构建到数组中。它不是你的实际数据，它是你的“表示层”。

private void printFullBorder(int col) { 
    for (int x=0; x<col+2; x++) {  //+2 because there are the leftmost + rightmost to account for
        System.out.print("#");  //unclear if this should be "#" or " #" based on your formatting, but whatever.
    }
}

printFullBorder(col);
for (int i=0; i<puzzle.length; i++){
    System.out.print("#" + Arrays.toString(puzzle[i]) + "#");
    System.out.println("");
}
printFullBorder(col);

Answer 7

public static String[] addBorder(String picture[]) {
    String[] border = new String[picture.length + 2];
    String pattern = "";
    for (int i = 0; i <= picture[0].length() + 1; i++) {
        pattern = pattern.concat("#");
    }
    border[0] = pattern;
    border[border.length - 1] = pattern;

    for (int i = 1; i <= border.length - 2; i++) {
        border[i] = "#" + picture[i - 1] + "#";
    }

    return border;
}

向数组添加边框

7 个答案: