Searching through arrays part 3

Question

   *  The moveTile method
   *  After the grid has been read and stored, the moveTile method
   *  takes in a single integer value that indicates a tile to move,
   *  and moves that tile into the blank tile's position, if it is a
   *  legal move. A move is only legal if the specified number exists
   *  in the grid, and if the specified tile's position is adjacent to
   *  the blank tile's position. The method returns a boolean value to
   *  indicate whether the move was made.
   * @param tileToMove The tile that is to be moved.
   * @return moveTile The boolean value which represents whether
   *                     or not the move was made.
  public boolean moveTile(int tileToMove){
    //set default boolean value to false
    boolean moveTile = false;
   //scans through the rows of the puzzle
    for(int scanRow=0;scanRow<grid.length;scanRow++){
      //scans through the columns of the puzzle
      for(int scanColumn=0;scanColumn<grid[0].length;scanColumn++){
       //scans through and checks if the desired tile exists
       //if it does exist, check if the '*' tile is beside it
      if(grid[scanRow][scanColumn]==tileToMove){
        //scans the tiles to the right of the tile being moved
        for(int besideRow=scanRow;besideRow<grid.length;besideRow++){
          //scans the tiles above the tile being moved
          for(int besideColumn = scanColumn;
              besideColumn < grid[0].length;
              besideColumn++){
            //scans the tile to the left of the tile being moved
            for(int besideRow2 = scanRow;
                besideRow2 < grid.length && besideRow2 > 0;
                besideRow2--){
              //scans the tile under the tile being moved
              for(int besideColumn2 = scanColumn;
                  besideColumn2 < grid[0].length && besideColumn2 > 0;
                  besideColumn2--){
                //if the '*' tile is above or to the right of the tile
                //being moved, then swap the files
                if(grid[besideRow][besideColumn]== -1){
                  //create a temporary storage variable to store the
                  //value of the '*' tile
                  //if the '*' tile was above or to the right of the
                  //tile being moved
                  int temp;
                  //sets the value of the temporary storage variable
                  //to the value of the '*' tile
                  temp = grid[besideRow][besideColumn];
                  //sets the value of the '*' tile to the value of the
                  //tile being moved
                  grid[besideRow][besideColumn] = grid[scanRow][scanColumn];
                  //sets the value of the tile being moved to the value of
                  //the '*' tile
                  grid[scanRow][scanColumn] = temp;
                  //return the boolean value true since the tile was moved
                  moveTile = true;
                //if the '*' tile is above or to the right of the tile
                //being moved, then swap the files
                if(grid[besideRow2][besideColumn2]== -1){
                  //create a temporary storage variable to store the
                  //value of the '*' tile
                  //if the '*' tile was above or to the right of the
                  //tile being moved
                  int temp2;
                  //sets the value of the temporary storage variable
                  //to the value of the '*' tile
                  temp2 = grid[besideRow2][besideColumn2];
                  //sets the value of the '*' tile to the value of the
                  //tile being moved
                  grid[besideRow2][besideColumn2] = grid[scanRow][scanColumn];
                  //sets the value of the tile being moved to the value of
                  //the '*' tile
                  grid[scanRow][scanColumn] = temp2;
                  //return the boolean value true since the tile was moved
                  moveTile = true;
    //returns the boolean true if the tile was moved and false if the tile
    //was not moved.
    //the default value is false
    return moveTile;
  }This is my code.... it works when the reference point of [0][0] is at the bottom left but when i changed my to string method to set the reference point of [0][0] at the top left.... it stopped swapping the tiles... it did give the correct boolean however

Answer 1

This is my code.... ... and quite a lot of code I might say (nicely documented though). I
strongly (sic) suggest that you strengthen your preconditions a bit, i.e.
don't just fill your grid[][] but keep track of the blank position also (just two
member variables).
Since you're dealing with a two dimensional thing, both a row and
column index are more appropriate than a single index number, although
the latter can easily be converted to the former. Let's denote the index
pair of the blank cell as bx, by.
Here's a simple method that determines whether or not an (x,y) pair
denotes a valid index pair in the grid:boolean isValid(int x, int y, char v) {
   try {
      return grid[x][y] == v;
   } catch (ArrayIndexOutOfBoundsException aioobe) {  }
   return false;
}... this method not just tests the validity of the (x,y) index values: it also
checks whether or not the (x,y) cell contains a 'v', whatever 'v' may be.
Now suppose you want to move a tile at position (x,y) to the blank
position (xb, yb). Here's how you swap those two positions:boolean swap(int x, int y) {
   if (isValid(x, y, grid[xb][yb]) {
      char tmp= grid[xb][yb];
      grid[xb][yb]= grid[x][y];
      grid[x][y]= tmp;
      xb= x; yb= y; // update the blank cell position
      return true;
   return false;
}The four neighbours of a cell (x,y) are easily found and a bit of logic
operator hacking yields:boolean move(int x, int y) {
   return swap(x-1, y) || swap(x+1, y) || swap(x, y-1) || swap(x, y+1);
}Finally, if you want to move a cell (x,y) containing a star '*' to the blank
cell, all you have to do is this:public boolean moveTile(int x, int y) {
   return isValid(x, y, '*') && move(x, y);
}Note that this last method is just a bit of makeup. You could join it with
the (non-public) 'move' method if you want.
Also note that a bit of functional decomposition and factoring results in
a lot less code.
kind regards,
Jos