搜索给定字符串数组中的单词

4 回答

• 2

  参考Sixie's code

  假设这是您程序的有效输入/输出？

  Size:
  4x4
  Matrix:
  a b c d
  e f g h
  i j k l
  m n o p
  Word: afkp
  (0,0)(3,3)
  

  我编辑了你的代码，所以它应该适用于这个表单上的输入（目前它区分大小写，但可以通过设置 .toLowerCase() 轻松更改

  Scanner k = new Scanner(System.in);
  System.out.println("Size: ");
  String s = k.nextLine();
  s.toUpperCase();
  
  int Xindex = s.indexOf('x');
  int x = Integer.parseInt(s.substring(0, Xindex));
  int y = Integer.parseInt(s.substring(Xindex + 1));
  
  System.out.println("Matrix:");
  char[][] matrix = new char[x][y];
  
  for (int i = 0; i < x; i++) {
      for (int p = 0; p < y; p++) {
          matrix[i][p] = k.next().charAt(0);
      }
  }
  
  System.out.print("Word: ");
  String word = k.next();
  
  int xStart = -1, yStart = -1;
  int xEnd = -1, yEnd = -1;
  
  // looping through the matrix
  for (int i = 0; i < x; i++) {
      for (int j = 0; j < y; j++) {
          // when a match is found at the first character of the word
          if (matrix[i][j] == word.charAt(0)) {
              int tempxStart = i;
              int tempyStart = j;
              // calculating all the 8 normals in the x and y direction
              // (the 8 different directions from each cell)
              for (int normalX = -1; normalX <= 1; normalX++) {
                  for (int normalY = -1; normalY <= 1; normalY++) {
                      // go in the given direction for the whole length of
                      // the word
                      for (int wordPosition = 0; wordPosition < word
                              .length(); wordPosition++) {
                          // calculate the new (x,y)-position in the
                          // matrix
                          int xPosition = i + normalX * wordPosition;
                          int yPosition = j + normalY * wordPosition;
                          // if the (x,y)-pos is inside the matrix and the
                          // (x,y)-vector normal is not (0,0) since we
                          // dont want to check the same cell over again
                          if (xPosition >= 0 && xPosition < x
                                  && yPosition >= 0 && yPosition < y
                                  && (normalX != 0 || normalY != 0)) {
                              // if the character in the word is not equal
                              // to the (x,y)-cell break out of the loop
                              if (matrix[xPosition][yPosition] != word
                                      .charAt(wordPosition))
                                  break;
                              // if the last character in the word is
                              // equivalent to the (x,y)-cell we have
                              // found a full word-match.
                              else if (matrix[xPosition][yPosition] == word
                                      .charAt(wordPosition)
                                      && wordPosition == word.length() - 1) {
                                  xStart = tempxStart;
                                  yStart = tempyStart;
                                  xEnd = xPosition;
                                  yEnd = yPosition;
                              }
                          } else
                              break;
                      }
                  }
              }
          }
      }
  }
  System.out.println("(" + xStart + "," + yStart + ")(" + xEnd + ","
          + yEnd + ")");
  k.close();
  

  回复于 2024-05-04T11:33:20+08:00
• 2

  我认为在开始编写代码之前需要更仔细地规划算法 . 如果我这样做，我的算法可能看起来像这样 .

  （1）遍历数组，寻找单词的第一个字符 .

  （2）每次找到第一个字符时，检查所有8个邻居，看看是否有第二个字符 .

  （3）每当我发现第二个字符作为第一个字符的邻居时，沿着数组中的字符迭代，向正确的方向移动，并根据单词检查每个字符 .

  （4）如果我匹配了整个单词，那么打印出我找到匹配的地方并停止 .

  （5）如果我到达了网格的边缘，或者发现了一个不匹配的字符，那么继续循环（2）的下一次迭代 .

  一旦确定算法，请考虑如何将每个步骤转换为代码 .

  回复于 2024-05-04T11:33:20+08:00
• 2

  如果我理解你的问题是对的 . 这是我现在快速回答的问题 .

  int H = matrix.length;
  int W = matrix[0].length;
  int xStart = -1, yStart = -1;
  int xEnd = -1, yEnd = -1;
  
  String word = "WordLookingFor".toLowerCase();
  
  for (int i = 0; i < H; i++) {
      for (int j = 0; j < W; j++) {
          if (matrix[i][j] == word.charAt(0)) {
              int tempxStart = i;
              int tempyStart = j;
              for (int x = -1; x <= 1; x++) {
                  for (int y = -1; y <= 1; y++) {
                      for (int k = 0; k < word.length(); k++) {
                          int xx = i+x*k;
                          int yy = j+y*k;
                          if(xx >= 0 && xx < H && yy >= 0 && yy < W && (x != 0 || y != 0)) {
                              if(matrix[xx][yy] != word.charAt(k))
                                  break;
                              else if (matrix[xx][yy] == word.charAt(k) && k == word.length()-1) {
                                  xStart = tempxStart;
                                  yStart = tempyStart;
                                  xEnd = xx;
                                  yEnd = yy;
                              }
                          } else
                              break;
                      }
                  }
              }
          }
      }
  }
  

  我用来检查所有8个邻居的一个小技巧是使用两个for循环来创建所有方向：

  for (int x = -1; x <= 1; x++) {
      for (int y = -1; y <= 1; y++) {
          if(x !=0 || y != 0)
              System.out.println(x + ", " + y);
      }
  }
  

  这创造了

  -1, -1
  -1, 0
  -1, 1
  0, -1
  0, 1
  1, -1
  1, 0
  1, 1
  

  注意：除了0,0之外的所有内容（您不想重新访问同一个单元格） . 其余的代码只是遍历字符矩阵，虽然你要查找的单词的整个长度，直到你找到（或者你没有找到）完全匹配 .

  回复于 2024-05-04T11:33:20+08:00
• 0

  这次问题是我怎么能打印单词的第一个和最后一个字母的索引 . 我在搜索每个单词后尝试了各种打印方式 . 但是，所有这些都没有奏效 . 我快要爆炸了 .

  int[] values = new int[2];
                  for(int i=0; i<matrix.length; i++){
                      for(int j=0; j<matrix[0].length; j++){
  
                          if(Character.toString(word.charAt(0)).equals(matrix[i][j]) == true || Character.toString(ReversedWord.charAt(0)).equals(matrix[i][j]) == true ){
                              System.out.print("("+ i + "," +j+")");
                              //First letter is found.Continue.
                          for(int p=1; p<word.length(); p++){
  
                          try{
                              for (int S = -1; S <= 1; S++) {
                                  for (int SS = -1; SS <= 1; SS++) {
                                      if(S !=0 || SS != 0)
                                          if(matrix[i+S][j+SS].equals(Character.toString(word.charAt(p))) && blocksAvailable[i+S][j+SS] == true || 
                                              matrix[i+S][j+SS].equals(Character.toString(ReversedWord.charAt(p))) && blocksAvailable[i+S][j+SS] == true) {
                                                  values[0] = i+S;
                                                  values[1] = j+SS;
                                                  blocksAvailable[i+S][j+SS] = false;
  
  
                                          }
                                  }
                              }
                          }catch (ArrayIndexOutOfBoundsException e) {}
  

  回复于 2024-05-04T11:33:20+08:00