Sudoku B

[JosAH]

Greetings,

The second part of the article defines two groups of methods. One method that
is able to read an entire Sudoku board and a couple of methods that can write
such a board, using a nice format.

We want a method that can read from a Reader stream and initialize the
board accordingly. It would be very convenient if we could read a text file
with content as shown in the example board as shown in th first part of this
article.

Basically we want to read 81 digits or dots; a dot and a '0' both describe an
empty cell, while the digits 1 ... 9 describe a filled cell. Here goes:

public boolean read(Reader r) {
 
    int i= 0, j= 0; // the first position of the board
 
    try {
        // keep on reading characters:
        for (int x; (x= r.read()) != -1; ) {
            // skip it if not a digit nor a dot
            if (!(Character.isDigit(x) || x == '.')) continue;
 
            // is it a digit 1 ... 9?
            if (!(x == '0' || x == '.'))
                    setValue(i, j, x-'0');
 
            // position i,j at next position, return when done
            if ((j= (j+1)%9) == 0)
                if (++i == 9) return true;
        }
    }
    catch (IOException ioe) { }
 
    // something went wrong
    return false;
}

The next group of methods can print a board given a Writer. It prints
the board using the same format as shown in the example board shown in the
first part of the article:

 
// print a horizontal separator line
private void printHorizontal(PrintWriter p) {
    p.println("+-------+-------+-------+");
}
 
// print a little vertical line
private void printVertical(PrintWriter p) {
    p.print("| ");
}
 
// print the Sudoku board
public void print(Writer w) {
 
    PrintWriter p= new PrintWriter(w);
 
    for (int i= 0; i < rows.length; i++) {
        if (i%3 == 0) printHorizontal(p);
        for (int j= 0; j < columns.length; j++) {
            if (j%3 == 0) printVertical(p);
            p.print(board[i][j]+" ");
        }
        printVertical(p);
        p.println();
    }
    printHorizontal(p);
    p.flush();
}

Note that both the read method and the write method do not close the character
streams; the Reader and Writer were passed in as a parameter so the caller of
these methods is responsible for closing the streams. The read method does
catch IOExceptions and simply returns false; all that the caller knows is that
a board could not be read for some reason, i.e. an IOException was thrown or
the content of the Reader didn't make up a valid board configuration.

Now we have all the primitive methods to manipulate a Sudoku board: we can
test and set a value anywhere on the board, we can reset a cell again, we
can initialize and entire board given a Reader and finally we can print the
Sudoku board given a Writer.

The third and last part of the article shows the actual Sudoku solver. All
methods shown above are part of a 'Sudoku' class. The solver method will also
be a member method. See you in part three of this article.

kind regards,

Jos