Comparing integers of rows and columns of a 2d array. Sudoku

Question

Hey I'm having trouble getting my code to compare the integers of a given row or column and block to make sure there are no duplicates within those parameters. I don't know if it would be a good idea separating the three contraints in 3 different methods or just trying to attempt to do all at once.

public static rowCheck(int[][] nsudokuBoard) {

    for (int i =0; i < 9; i++) {

        for (int j = 0; j < 9; j++) { 
            // (nsudokuBoard)
        }
    }
}

this is my code im starting. before you guys bash on me for not even being able to compile this im stuck on how to compare all the values of a row of the 2d array.

Answer 1

You can compare all the values of the 2d array as shown in the code below:

void validate(final int[][] nsudokuBoard) {
    final int width = nsudokuBoard[0].length;
    final int depth = nsudokuBoard.length;

    for (int i = 0; i < width; i++) {
        int j = i;
        int reference = nsudokuBoard[i][j];

        do {
            if (j < width) {
                int current = nsudokuBoard[i][j];

                if (current == reference) {
                // invalid entry found do something
                }
            }
            if (j < depth) {
                // note reversed indexes
                int current = nsudokuBoard[j][i];

                if (current == reference) {
                // invalid entry found do something
                }
            }
            ++j;
        } while ((j >= width) || (j >= depth));
    }
}

I haven't tried to compile this code, but it should give you an idea of how to accomplish your task. I would suggest that rather than passing in int[][] sudokuBoard that you should define a class which encapsulates the concept of a SudokuSquare and pass in SudokuSquare[][] , that way your validate method can return a List<SudokuSquare> containing all the offending entries.

Answer 2

I'll show how you might do it for one row, and then you can figure out the rest. I'm assuming your values are 1 through 9 inclusive, and that you don't have any zeroes or any "unfilled entries."

boolean isRowValid(int[][] grid, int row) {
  boolean[] seen = new boolean[9];
  int row; // chosen somewhere else
  for (int col = 0; col < 9; col++) {
    if (seen[grid[row][col] - 1]) { // if we've seen this value before in this row
      return false; // there is a duplicate, and this is a bad sudoku
    }
    seen[grid[row][col] - 1] = true; // mark us as having seen this element
  }
  return true; // we're all good
}
return true; // this row is fine

Answer 3

make a class Cell with fields row,col,block,value; then make a class Matrix with field cells = cell[], fill matrix. make a class checker with main method Matrix matrix = init(int[][]) and check(matrix), where init(·) fills the matrix. boolean ok = check(matrix) where check(Matrix) does if(!rowcheck())return false; if(!colcheck()) return false etc;

create some methods like getrows(), getrow(r) and for(Cell cell: matrix.values()) to filter out the ones you want.

a bit tedious but i have done it and it is solid as rock.

As a note, filtering over matrix may seem stupid but computers are fast and the problem is O(1) since it is 9x9.