Java- vérification de la valeur dans un tableau multidimensionnel

Question

Je travaille sur une affectation pour créer un jeu de type tictactoe en utilisant un tableau multidimensionnel, une classe séparée avec des méthodes à appeler par la classe principale.

Le tableau est 3 X 3 et est initialisé à zéro. Lorsque le joueur 1 choisit un emplacement sur le plateau, un 1 est placé dans cet index spécifique. Ensuite, l'invite permet au joueur 2 de faire sa sélection. Chaque fois qu'un joueur prend son tour une méthode est invoquée pour vérifier si le tableau est complet, s'il est complet (rempli avec 1 et 2 ') alors le jeu est appelé un tirage. Cette méthode ne fonctionne pas comme elle le devrait et elle appelle le jeu un tirage parfois sur le deuxième coup. Voici ma méthode que j'utilise.

public boolean isBoardComplete() 
{ 
    // sets complete to true 
    boolean complete = true; 

    //will change complete to false 
    for (int i = 0; i < 3; i++) 
    { 
     for(int j =0; j < 3; j++) 
     { 
      if (_board[i][j] == 0) 
      { 
       complete = false; 
      } 
     } 
    } 
    return complete; 
} 

Answer 1

Ce code ne pose pas de problème. Vous devez vous assurer que le tableau est initialement rempli de zéros avant de commencer la partie. J'imprimerais l'état du tableau pour m'assurer que c'est le cas. Sinon, assurez-vous que vous utilisez correctement votre valeur booléenne lorsque vous le renvoyez à partir de cette méthode.

Answer 2

Le tableau est-il déclaré en tant que tableau Integer ou tableau int? Cela fera une différence si vous utilisez le == et auto-unboxing (même si avec de petits nombres, ils doivent être mis en cache). À part cela, je dirais que votre tableau n'est pas correctement initialisé. Post le code qui appelle cette méthode et le code qui initialise votre tableau. Le problème réside probablement dans l'un de ces deux endroits.

Answer 3

essayez ceci:

public boolean isBoardComplete() 
{ 
    //will change complete to false 
    for (int i = 0; i < 3; i++) 
    { 
    for(int j =0; j < 3; j++) 
    { 
     if (_board[i][j] == 0) 
     { 
      return false; 
     } 
    } 
    } 
    return true; 
} 

Answer 4

Si vous utilisez Java 5 ou au-dessus, vous pouvez utiliser Arrays.deepEquals method.From les javadocs, « cette méthode est appropriée pour une utilisation avec des tableaux imbriqués de profondeur arbitraire. »

Exemple: -

String[][] ticTacToe = { {"X", "O", "O"}, 
          {"O", "X", "X"}, 
          {"X", "O", "X"}}; 
    System.out.println(Arrays.deepToString(ticTacToe)); 

    String[][] ticTacToe2 = { {"O", "O", "X"}, 
           {"O", "X", "X"}, 
           {"X", "O", "X"}}; 

    String[][] ticTacToe3 = { {"X", "O", "O"}, 
           {"O", "X", "X"}, 
           {"X", "O", "X"}}; 

    if (Arrays.deepEquals(ticTacToe, ticTacToe2)) { 
     System.out.println("Boards 1 and 2 are equal."); 
    } else { 
     System.out.println("Boards 1 and 2 are not equal."); 
    } 

    if (Arrays.deepEquals(ticTacToe, ticTacToe3)) { 
     System.out.println("Boards 1 and 3 are equal."); 
    } else { 
     System.out.println("Boards 1 and 3 are not equal."); 
    } 
    } 

Answer 5

Voici mon code. J'ai la classe principale (TicTacToeApplication) et la classe TTTboard.

import java.util.Scanner; 

public class TicTacToeApplication { 

    public static void main(String[] args) 
    { 
     // declare variables including our TTT board 

     TTTBoard myGame = new TTTBoard(); 
     Scanner input = new Scanner(System.in); 
     int row; 
     int col; 


     while(myGame.determineWinner() == 0 && !myGame.isBoardComplete()) 
     { 

      myGame.displayBoard(); 


      System.out.println("Player " + myGame.getCurrentPlayer()); 
      System.out.println("Make your move."); 
      System.out.print("Row please (1-3):"); 
      row = input.nextInt(); 


      while(row < 1 || row > 3) 
      { 
       System.out.println("Invalid Row."); 
       System.out.print("Try again (1-3):"); 
       row = input.nextInt(); 
      } 

      System.out.print("Col please (1-3):"); 
      col = input.nextInt(); 


      while(col < 1 || col > 3) 
      { 
       System.out.println("Invalid Col."); 
       System.out.print("Try again (1-3):"); 
       col = input.nextInt(); 
      } 

      // while the move is invalid make them make another move 
      while(!myGame.makeMove(row, col)) 
      { 
       System.out.println("Invalid Move... Try Again."); 
       System.out.print("Row please (1-3):"); 
       row = input.nextInt(); 

       // error trap for valid row 
       while(row < 1 || row > 3) 
       { 
        System.out.println("Invalid Row."); 
        System.out.print("Try again (1-3):"); 
        row = input.nextInt(); 
       } 

       System.out.print("Col please (1-3):"); 
       col = input.nextInt(); 

       // error trap for valid col 
       while(col < 1 || col > 3) 
       { 
        System.out.println("Invalid Col."); 
        System.out.print("Try again (1-3):"); 
        col = input.nextInt(); 
       } 
      } 
     } 

     // if we left the loop because the boards full and there's no winner 
     // it must be a cats game 
     if (myGame.determineWinner() == 0) 
     { 
      System.out.println("Sorry - Cat's Game"); 
     } 
     else 
     { 
      System.out.print("The Winner is Player "); 
      if (myGame.getCurrentPlayer() == 1) 
      { 
       System.out.println("2"); 
      } 
      else 
      { 
       System.out.println("1"); 
      } 
     } 
    } 

} 

---

public class TTTBoard 
{ 

    private int [][] _board; 
    private int _player; 


    public TTTBoard() 
    { 
     _player = 0; 
     _board = new int [3][3]; 

     for (int row = 0; row < 3; row++) 
     {  
      for(int column = 0; column < 3; column++) 
      { 
       _board[row][column] = 0; 
      } 
     } 
    } 


    public boolean makeMove(int row, int col) 
    { 
     row = row - 1; 
     col = col - 1; 

     // Checks to see if board location is occupied and a move can be made 

     if (_board[row][col] == 0) 
     { 
      _board[row][col] = _player; 
      return false; 
     } 
     else 
     { 
      return true; 
     } 
    } 


    public boolean isBoardComplete() 
    { 
     for (int row = 0; row < 3; row++) 
     { 
      for (int column = 0; column <3; column++) 
      { 
       if (_board [row][column] == 0) 
       { 
        return false; 
       } 

      } 
     } 

     return true; 
    } 


    public int determineWinner() 
    { 
     // First check rows and columns 
      int winner = 0; 

     // Check for winner in row 1 
     if (_board[0][0] == _board[0][1] && _board[0][0] == _board[0][2] && 
       _board[0][0] != 0) 
     { 
      winner = _board[0][0]; 
     } 

     // Check for winner in row 2 
     if (_board[1][0] == _board[1][1] && _board[1][0] == _board[1][2] && 
       _board[1][0] != 0) 
     { 
      winner = _board[1][0]; 
     } 

     // Check for winner in row 3 
     if (_board[2][0] == _board[2][1] && _board[2][0] == _board[2][2] && 
       _board[2][0] != 0) 
     { 
      winner = _board[2][0]; 
     } 

     // Check for winner in col 1 
     if (_board[0][0] == _board[1][0] && _board[0][0] == _board[2][0] && 
       _board[0][0] != 0) 
     { 
      winner = _board[0][0]; 
     } 

     // Check for winner in col 2 
     if (_board[0][1] == _board[1][1] && _board[0][1] == _board[2][1] && 
       _board[0][1] != 0) 
     { 
      winner = _board[0][1]; 
     } 

     // Check for winner in col 3 
     if (_board[0][2] == _board[1][2] && _board[0][2] == _board[2][2] && 
       _board[0][2] != 0) 
     { 
      winner = _board[0][2]; 
     } 

     // Check for winner in first diagonal 
     if (_board[0][0] == _board[1][1] && _board[0][0] == _board[2][2] && 
       _board[0][0] != 0) 
     { 
      winner = _board[0][0]; 
     } 
     // Check for winner in 2nd diagonal 
     if (_board[2][0] == _board[1][1] && _board[2][0] == _board[0][2] && 
       _board[2][0] != 0) 
     { 
      winner = _board[2][0]; 
     } 

     return winner; 
    } 


    public void displayBoard() 
    { 
     System.out.println(); 

     for (int r=0; r<_board.length; r++) 
     { 

      for (int c=0; c<_board[r].length; c++) 
      { 

       System.out.print(" " + _board[r][c]); 
      } 

      System.out.println(""); 
     } 

    } 


    public int getCurrentPlayer() 
    { 
     if (_player == 0) 
     { 
      return _player = 1; 
     } 
     if (_player == 1) 
     { 
      return _player = 2; 
     } 
     else 
     { 
      return _player = 1; 
     } 

    } 
} 

Answer 6

On dirait que le problème est dans la méthode makeMove(). Le code retourne "faux" après avoir fait le mouvement et à partir du flux de code, il est clair que la méthode devrait retourner "vrai" pour un mouvement valide.

Essayez cette

public boolean makeMove(int row, int col) { 
     row = row - 1; col = col - 1; 

     // Checks to see if board location is occupied and a move can be made 
     if (_board[row][col] == 0) 
     { 
      _board[row][col] = _player; 
      return true; 
     } 
     return false; 

    }