Programming Design Help - How to Structure a Sudoku Solver program? [closed]

Answer 1

The simplest way to do it is to represent the board by a 2D 9x9 array. You'll want to have references to each row, column and 3x3 box as a separate object, so storing each cell in a String makes more sense (in Java) than using a primitive. With a String you can keep references to the same object in multiple containers.

Answer 2

A class containing a 1d array of 81 ints (0 is empty) is sufficient for the rule class. The rule class enforces the rules (no duplicate numbers in each row, column or 3x3 square). It also has an array of 81 bools so it knows which cells are fixed and which need to be solved. The public interface to this class has all the methods you need to manipulate the board:

int getCell(int x, int y);
bool setCell(int x, int y, int value);
bool clearCell(int x, int y);
int[] getRow(int x);
int[] getCol(int y);
int[] getSubBox(int x, int y);
void resetPuzzle();
void loadPuzzle(InputStream stream);

Then your solver uses the public interface to this class to solve the puzzle. The class structure of the solver I presume is the purpose of writing the 5 millionth Sudoku solver. If you are looking for hints, I'll edit this post later.

Answer 3

Well, I would use one class for the sudoku itself, with a 9 x 9 array and all the functionality to add numbers and detect errors in the pattern.

Another class will be used to solve the puzzle.

Answer 4

Maybe a design that had a box per square, and another class to represent the puzzle itself that would have a collection of boxes, contain all the rules for box interactions, and control the overall game would be a good design.

Answer 5

First, it looks like there are two kinds of cells.

• Known calls; those with a fixed value, no choices.

• Unknown cells; those with a set of candidate values that reduces down to a single final value.

Second, there are several groups of cells.

• Horizontal rows and Vertical columns which must have one cell of each value. That constraint is used to remove values from various cells in the row or column.

• 3x3 blocks which must have one cell of each value. That constraint is used to remove values from various cells in the block.

Finally, there's the overall grid. This has several complementary views.

• It's 81 cells.

• The cells are also collected into a 3x3 grid of 3x3 blocks.

• The cells are also collected into 9 columns.

• The cells are also collected into 9 rows.

And you have a solver strategy object.

1. Each Unknown cell it set to having set( range(1,10) ) as the candidate values.

2. For each row, column and 3x3 block (27 different collections):

   a. For each cell:

   • If it has definite value (Known cells and Unknown cells implement this differently): remove that value from all other cells in this grouping.

The above must be iterated until no changes are found.

At this point, you either have it solved (all cells report a definite value), or, you have some cells with multiple values. Now you have to engage in a sophisticated back-tracking solver to find a combination of the remaining values that "works".

Answer 6

Do you need to do it in Python or Java? I do a lot of programming in Python, but this can be done much more concisely with integer program using a language like AMPL or GLPK, which I find more elegant (and generally more efficient) for problems like this.

Here it is in AMPL, although I haven't verified how this works: http://taha.ineg.uark.edu/Sudoku.txt