How do I create a 2x2 subarray of a 5x5 2d array, rotate it, then add it back to the original array?

Question

I'm trying to create a game like "fifteen" but instead of sliding tiles into one empty space, the empty space is removed and you have to choose individual 2x2 grids to rotate in order to get all the numbers in the correct order.

I'm stuck as to how to create a subarray from the original and have it so that the rotation of the subarray is applied to the original array.

For example:

01 02 03 04 05  
06 07  10  
11 12  15  
16 17 18 19 20  
21 22 23 24 25  

in order to solve the game, you would need to choose the number 9 and and rotate {09, 14} {08, 13} clockwise.

I'm relatively new to programming and java so any help would be greatly appreciated!

Answer 1

Assuming you have a two dimensional array (an array of columns) then your first index is the x coordinate and the second index the y coordinate in your grid. The x and y parameter present the position where the user has clicked on. However, this method will throw an exception if you choose a position at the border.

private static int[][] rotate2x2SubArray(int[][] grid, final int x, final int y) {
    final int topLeft = grid[x][y];
    final int topRight = grid[x + 1][y];
    final int bottomRight = grid[x + 1][y + 1];
    final int bottomLeft = grid[x][y + 1];

    //topRight's new value is topLeft's old value
    grid[x + 1][y] = topLeft;
    //bottomRight's new value is topRight's old value
    grid[x + 1][y + 1] = topRight;
    //bottomLeft's new value is bottomRight's old value
    grid[x][y + 1] = bottomRight;
    //topLeft's new value is bottomLeft's old value
    grid[x][y] = bottomLeft;

    return grid;
}

This is just my approach. There a probably a hundred ways which might be faster/slower or more flexible(rotate a variable size).

Answer 2

Here's a proof of concept. This is the original 5 x 5 array.

  1  2  3  4  5
  6  7  8  9 10
 11 12 13 14 15
 16 17 18 19 20
 21 22 23 24 25

This is the array after the 8 has been rotated counter-clockwise.

  1  2  3  4  5
  6  7  9 14 10
 11 12  8 13 15
 16 17 18 19 20
 21 22 23 24 25

This is the array after the 16 has been rotated clockwise.

  1  2  3  4  5
  6  7  9 14 10
 11 12  8 13 15
 21 16 18 19 20
 22 17 23 24 25

Here's the runnable code. I didn't check for the row or column being less than the last row or column. All I did was create the method to rotate the 2 x 2 subarray.

public class RotateSubArray {

    public static void main(String[] args) {
        RotateSubArray rotate = new RotateSubArray();
        int[][] array = rotate.createArray();
        System.out.println(rotate.printArray(array));
        array = rotate.rotateSubArray(array, 1, 2, false);
        System.out.println(rotate.printArray(array));
        array = rotate.rotateSubArray(array, 3, 0, true);
        System.out.println(rotate.printArray(array));
    }
    
    public int[][] createArray() {
        int[][] output = new int[5][5];
        
        int count = 1;
        for (int i = 0; i < output.length; i++) {
            for (int j = 0; j < output[i].length; j++) {
                output[i][j] = count++;
            }
        }
        
        return output;
    }
    
    public String printArray(int[][] output) {
        StringBuilder builder = new StringBuilder();
        
        for (int i = 0; i < output.length; i++) {
            for (int j = 0; j < output[i].length; j++) {
                builder.append(String.format("%3d", output[i][j]));
            }
            builder.append(System.lineSeparator());
        }
        
        return builder.toString();
    }
    
    public int[][] rotateSubArray(int[][] array, int row, int column, 
            boolean clockwise) {
        int temp = array[row][column];
        int nextRow = row + 1;
        int nextColumn = column + 1;
        
        if (clockwise) {
            array[row][column] = array[nextRow][column];
            array[nextRow][column] = array[nextRow][nextColumn];
            array[nextRow][nextColumn] =  array[row][nextColumn];
            array[row][nextColumn] = temp;
        } else {
            array[row][column] = array[row][nextColumn];
            array[row][nextColumn] = array[nextRow][nextColumn];
            array[nextRow][nextColumn] = array[nextRow][column];
            array[nextRow][column] = temp;
        }
        
        return array;
    }

}