SoDuko puzzle

[Sonny Pondrom]

There is a puzzle that is becoming very popular called SuDuko. It was on the CBS Sunday Morning program today. It is like a cross-word puzzle but with digits 1 thru 9 instead of letters. It started in the U.S. and became very popular in Japan. There is a game player written for it using Windows, but I have not seen one for my Mac.

The board has 9 X 9 boxes laid out in a square. Each box has 9 fields laid out in a 3 x 3 square. Some of the fields are initiated with numbers. An easy game has many initial numbers and a more difficult game has fewer initial numbers.

The game with an unlimited number of puzzles could be written in Java by using a random number generator. A new puzzle could be generated by a text file with the starting numbers on nine input lines. Each line could have nine entries that are numbers 0,1,2,3,4,5,6,7,8 and 9. The zero could represent a blank puzzle field. The input level of difficulty could be the number of starting values.

The Daily SuDuko web site puzzle for 4 Dec 2005 is shown below as provided by Daily SuDuko Puzzle. This puzzle is represented by 81 numbers on the 9 lines with 3 sets of 3 numbers:

0,0,0, 0,0,0, 0,1,2
0,0,0, 0,5,1, 3,8,0
0,8,0, 0,0,6, 0,0,0

1,0,0, 2,4,0, 0,7,0
0,0,0, 0,3,0, 0,0,0
0,7,0, 0,6,5, 0,0,3

0,0,0, 4,0,0, 0,2,0
0,5,9, 6,8,0, 0,0,0
8,1,0, 0,0,0, 0,0,0

The object of the puzzle is to replace the 0's (blanks) with numbers 1 thru 9 such that each row, each column and each 3 x 3 box has only the numbers 1 thru 9. Can anyone write a Java code that would solve this very hard puzzle with only 25 starting numbers?

[Darren Horsman]

Wikipedia lists sudoku as:

it is a registered trademark of puzzle publisher Nikoli Co. Ltd in Japan

Not American after all I take it. We have had it in Britian for around a year now. I'll have a go at this and post results sometime after tomorrow.

[Henry Wong]

The daily SuDoku site that you mentioned actually have a solver -- just choose draw, enter the values, and get either the next possible number, or the complete solution. Since you got the puzzle from that very site, you can also send the puzzle to the draw function directly.

If you want more SuDokus, the websudoku.com site has literally billions of them.

Apparently, they are also certain rules for a properly formed SuDoku. They can only have one solution, and must not be reached by guessing. I think the difficulty rating is also based on what type of logic techniques are used.

I know this is the "programming diversion" forum, but... IMHO, developing a solver is not very useful. What would be the point? SuDoku is probably a more addictive diversion, than any programming diversion.

Henry

[Henry Wong]

Okay, so I am an addict... It wasn't too bad. Took about 40 minutes.


Please skip if you don't want the solution





Last chance








Okay




735 894 612
624 751 389
981 326 457

193 248 576
546 137 298
278 965 143

367 419 825
459 682 731
812 573 964

[Ryan McGuire]

public class sudoku {
 
    // Is every number 1-9 in the given rectangle 0..1 times?
    public static boolean isRectangleLegal(int[][] board, int x1, int x2, int y1, int y2, String errormsg) {
boolean[] isPresent = {false, false, false, false, false, false, false, false, false, false};
 
for (int x=x1; x<=x2; x++) {
    for (int y=y1; y<=y2; y++) {
if (board[x][y] > 0) {
    if (isPresent[board[x][y]]) {
//System.out.println(errormsg + ": multiple " + board[x][y] + "s");
return false;
    }
    isPresent[board[x][y]] = true;
}
    }
}
return true;
    }
 
    public static boolean isLegal(int[][] board) {
// Check the nine blocks.
if (!isRectangleLegal(board, 0, 2, 0, 2, "Block 1")) return false;
if (!isRectangleLegal(board, 3, 5, 0, 2, "Block 2")) return false;
if (!isRectangleLegal(board, 6, 8, 0, 2, "Block 3")) return false;
if (!isRectangleLegal(board, 0, 2, 3, 5, "Block 4")) return false;
if (!isRectangleLegal(board, 3, 5, 3, 5, "Block 5")) return false;
if (!isRectangleLegal(board, 6, 8, 3, 5, "Block 6")) return false;
if (!isRectangleLegal(board, 0, 2, 6, 8, "Block 7")) return false;
if (!isRectangleLegal(board, 3, 5, 6, 8, "Block 8")) return false;
if (!isRectangleLegal(board, 6, 8, 6, 8, "Block 9")) return false;
 
// check the nine columns
if (!isRectangleLegal(board, 0, 0, 0, 8, "Column 0")) return false;
if (!isRectangleLegal(board, 1, 1, 0, 8, "Column 1")) return false;
if (!isRectangleLegal(board, 2, 2, 0, 8, "Column 2")) return false;
if (!isRectangleLegal(board, 3, 3, 0, 8, "Column 3")) return false;
if (!isRectangleLegal(board, 4, 4, 0, 8, "Column 4")) return false;
if (!isRectangleLegal(board, 5, 5, 0, 8, "Column 5")) return false;
if (!isRectangleLegal(board, 6, 6, 0, 8, "Column 6")) return false;
if (!isRectangleLegal(board, 7, 7, 0, 8, "Column 7")) return false;
if (!isRectangleLegal(board, 8, 8, 0, 8, "Column 8")) return false;
 
// check the nine rows
if (!isRectangleLegal(board, 0, 8, 0, 0, "Row 0")) return false;
if (!isRectangleLegal(board, 0, 8, 1, 1, "Row 1")) return false;
if (!isRectangleLegal(board, 0, 8, 2, 2, "Row 2")) return false;
if (!isRectangleLegal(board, 0, 8, 3, 3, "Row 3")) return false;
if (!isRectangleLegal(board, 0, 8, 4, 4, "Row 4")) return false;
if (!isRectangleLegal(board, 0, 8, 5, 5, "Row 5")) return false;
if (!isRectangleLegal(board, 0, 8, 6, 6, "Row 6")) return false;
if (!isRectangleLegal(board, 0, 8, 7, 7, "Row 7")) return false;
if (!isRectangleLegal(board, 0, 8, 8, 8, "Row 8")) return false;
return true;
    }
 
    public static boolean solve(int[][] board) {

// Find a position that's still empty.
for (int x=0; x<9; x++) {
    for (int y=0; y<9; y++) {
if (board[x][y] == 0) {
 
    // Try each possibile value in this space
    // and see if the rest of the puzzle can be filled in.
    for (board[x][y]=1; board[x][y]<=9; board[x][y]++) {
if (isLegal(board) && solve(board)) {
    return true;
}
    }
 
    // There is no value that we can put in the first
    // empty space that was found, so the puzzle is
    // unsolvable given the values put in up to this
    // point.
    board[x][y] = 0;
    return false;
}
    }
}
 
// There were no empty spaces to fill in, so the
// puzzle must be solved.
return true;
    }
 
    public static void printBoard(int[][] board) {
        for (int x=0; x<9; x++) {
    System.out.println(x%3==0 ? "+-----+-----+-----+" : "|     |     |     |");
    for (int y=0; y<9; y++)
System.out.print((y%3==0 ? "|" : " ") + board[x][y]); 
    System.out.println("|");
}
System.out.println("+-----+-----+-----+");
    }
 
    public static void main(String[] argv) {
 
int board[][] = {{0,0,0, 0,0,0, 0,1,2},
{0,0,0, 0,5,1, 3,8,0},
{0,8,0, 0,0,6, 0,0,0},

{1,0,0, 2,4,0, 0,7,0},
{0,0,0, 0,3,0, 0,0,0},
{0,7,0, 0,6,5, 0,0,3},

{0,0,0, 4,0,0, 0,2,0},
{0,5,9, 6,8,0, 0,0,0},
{8,1,0, 0,0,0, 0,0,0} };
 
if (solve(board))
    printBoard(board);
else
    System.out.println("no solution");
    }
}

Produces this output:

+-----+-----+-----+
|7 3 5|8 9 4|6 1 2|
|     |     |     |
|6 2 4|7 5 1|3 8 9|
|     |     |     |
|9 8 1|3 2 6|4 5 7|
+-----+-----+-----+
|1 9 3|2 4 8|5 7 6|
|     |     |     |
|5 4 6|1 3 7|2 9 8|
|     |     |     |
|2 7 8|9 6 5|1 4 3|
+-----+-----+-----+
|3 6 7|4 1 9|8 2 5|
|     |     |     |
|4 5 9|6 8 2|7 3 1|
|     |     |     |
|8 1 2|5 7 3|9 6 4|
+-----+-----+-----+

[ December 28, 2005: Message edited by: Ryan McGuire ]

[Sonny Pondrom]

WOW That is amazing.

[David O'Meara]

It is a little brute-force though, and there is plenty of other logic that is interesting to implement. Maybe lok at a Java sudoku solver

[Jeff Albertson]

Originally posted by Darren Horsman:

Not American after all I take it. We have had it in Britian for around a year now. I'll have a go at this and post results sometime after tomorrow.

Take a closer look at the Wikipedia article. It states that:

Although first published in 1979, Sudoku initially caught on in Japan in 1986 and attained international popularity in 2005.

and

Dell Magazines, the puzzle's originator, has been using numerals for Number Place in its magazines since they first published it in 1979.

Dell is an American publisher. Yup, su doku is Japanese by adoption, like tofu

[steno druetta]

i'm sorry but I think sudoku is such a b�llsh�t. here in italy it has started to be famous last summer. when i was working in greece in an international holyday club i saw so many people trying to handle that... the "audience" was divided between the da vinci code (another b�llsh�t) and sudoku.
i apologize, i'm not so fond of "numbers", i'm a crosswords lover, i can solve any kind of scheme in few minutes...

[Ryan McGuire]

Originally posted by David O'Meara:
It is a little brute-force though, and there is plenty of other logic that is interesting to implement. Maybe lok at a Java sudoku solver

A LITTLE???

My take on brute force:
I guess it depends on how many puzzles you plan to solve. Why take 8 hours to write an elegant program to solve the puzzle in 87 ms, when you can spend just 30 min to write brute force code that solves it in 15 sec?
[ December 12, 2005: Message edited by: Ryan McGuire ]

[David O'Meara]

But it depends if your interested in the answer or the question. Migrating the same logic used to solve it by pencil can be an interesting exercise... to some

[Sonny Pondrom]

Solving by computer rather than pencil is better. I started to write a Java code to make it easier, but then my plans looked so much like a spreadsheet, that I decided to use one.

I call it "Sum 45" because it calculates the sum of the missing numbers for each box, row and column. The puzzle initially has a string with a single quote and 9 multi-colored numbers (1-9) in each cell. The single quote is there to avoid the cell being added to the sum of missing numbers. You have to replace these cells with the given puzzle entries. I make these number default font size 36 to make them different from the other cells.

To start solving the puzzle, you begin deleting the bad digits from the number string. When you get down to just one digit, then you delete the single quote as well. When a box, row or column is completed, then the sum of missing numbers will change from the starting value of 45 to zero.

I would show you a picture (Sum_45.tiff), but I don't know how to upload one.
Send me an email if you would like a copy of the Excel file. [e-mail]
[ December 19, 2005: Message edited by: Sonny Pondrom ]

[Mike Noel]

I like Ryan's solution. It's just a simple depth-first search of the game space. If I was still teaching second year CD students I'd probably have this as one of my programming assignments.

You might be able to prune the tree down a bit with a smarter inner loop (the for 1..9 loop). At the point where the comments say "// Try each possible..." you could generate three Sets. One for the available row numbers, one for the available column numbers, and one for the available rectangle numbers. Then using set intersection between the three you could end up with a Set of all of the available numbers for that position. Use an iterator over that set in a while loop instead of the for loop.

If the result Set was ever empty then there would be no need to go down that path anymore.

Just a thought.

BTW, the fact that this can easily be solved with a depth-first approach is the main reason that I haven't been all that excited about the game. Kinda like word-search puzzles. No real thought involved, just busy work.

(Yeah, I'm about to get smacked on the head by a zillion soduko fans...)

_M_

[Arjunkumar Shastry]

I think solving Sudoku by pencil than computer is better.Every Sudoku puzzle can not be solved by brute force on paper.Some hard Sudoku puzzles take more than 1 hour or sometimes 2 hours in my case.It also required actually writing down possible numbers and then deducing the possible solution.Interesting question will be "How will you generate Sudoku puzzle?" and how will you grade the puzzles from easy,medium,hard.
Say I fill all 81 squares according to rules,then which squares should be left blank to make puzzle easy,medium,hard?Here you need to write a program.

[Henry Wong]

By definition, a properly formed Sudoku must have only one possible answer -- so hence, a bruce force solution should not only solve every sudoku, it can also be able to determine if the sudoku is properly formed.

However, I don't think that a brute force solution would be able to rate the sudoku. I believe that the daily sudoku site is able to determine whether the puzzle is easy, or hard, based on what techniques it used to solve the puzzle -- which means that it doesn't use a brute force solution.

BTW, have anyone seen the daily sudoku recently. I haven't tried them yet, but I noticed that they now have Christmas Sudokus...

Henry

[Jessica Sant]

found this cool Javascript Sudoku solver: http://shannonandmike.net/sudoku/

[Ram Bhakt]

Originally posted by steno druetta:

i'm a crosswords lover

which is another kind of b�llsh�t

[Ryan McGuire]

Originally posted by Jessica Sant:
found this cool Javascript Sudoku solver: http://shannonandmike.net/sudoku/

Cool? It'd be even cooler if it actually solved the puzzle I put in.

Today's Daily SuDoku (click here and then on Thu 5-Jan-06 "very hard" puzzle) seems to be too hard for the (current version of the) solver.

---1----5
--7-48--2
-2-9----7
-3---29--
5-------4
--68---1-
8----1-4-
6--28-5--
1----4---

(I'm so glad my code works with this initial data. )

[Jesper de Jong]

Originally posted by steno druetta:
i'm sorry but I think sudoku is such a b�llsh�t. ...
i apologize, i'm not so fond of "numbers", i'm a crosswords lover, i can solve any kind of scheme in few minutes...

Sudoku is not a numbers game!

You can replace the numbers with any kind of symbol you like. If you don't like numbers but you do like letters, try replacing the numbers '1', '2', '3', ... in Sudoku with letters 'A', 'B', 'C', ... and it will still be the same game.

[Jesper de Jong]

Originally posted by Arjunkumar Shastry:
I think solving Sudoku by pencil than computer is better.Every Sudoku puzzle can not be solved by brute force on paper.Some hard Sudoku puzzles take more than 1 hour or sometimes 2 hours in my case.It also required actually writing down possible numbers and then deducing the possible solution.Interesting question will be "How will you generate Sudoku puzzle?" and how will you grade the puzzles from easy,medium,hard.
Say I fill all 81 squares according to rules,then which squares should be left blank to make puzzle easy,medium,hard?Here you need to write a program.

Have a look at http://sudoku.sourceforge.net

It includes a program to generate puzzles and a solver with some very clever algorithms.

[Joseph Kulandai]

Check this code: http://kulandai.blogspot.com/2006/10/sudoku-puzzle-java-source.html

[Jim Yingst]

Interesting, Joseph. You should try using one of the input arrays Ryan tried above. I input the one he showed in the code itself, and your code is still working on it after about a half hour. I don't know if it's in an infinite loop or not.

I recently got into sudoku a bit thanks to a few plane trips with nothing else to do. Unfortunately the book I grabbed has some quality issues, and about a tenth of the puzzles in it have more than one solution. Which leads to wasted time as you try in vain to find a way to choose between several possibilities, and there isn't any. So I figured a sudoku solver would be useful to tell me how many solutions there were. Being lazy, I grabbed Ryan's code above as a starting point. I was surprised how fast a brute-force solution could be - six seconds for for the sample puzzle Ryan used, on my laptop. Being a geek though, I felt compelled to find some ways to try to optimize it. I fully agree with Ryan's "my take on brute force" above - but in my case, I hadn't done any work of my own on the problem, and optimizing a simple existing solution seemed more productive than making my own from scratch. As a result, I was able to find some fairly minor changes that took the execution time for the demo problem from 6 seconds down to just under one second. (Yay!) Here's the code:

public class RMSudoku2 {
 
    // Is every number 1-9 in the given rectangle 0..1 times?
    public static boolean isRectangleLegal(int[][] board, 
            int x1, int x2, int y1, int y2, String errormsg) {
        boolean[] isPresent = new boolean[10];
 
        for (int x = x1; x <= x2; x++) {
            for (int y = y1; y <= y2; y++) {
                if (board[x][y] > 0) {
                    if (isPresent[board[x][y]]) {
//System.out.println(errormsg + ": multiple " + board[x][y] + "s");
                        return false;
                    }
                    isPresent[board[x][y]] = true;
                }
            }
        }
        return true;
    }
 
    public static boolean isLegal(int[][] board, int x, int y) {
 
        // check column
        if (!isRectangleLegal(board, x, x, 0, 8, "Column"))
            return false;
 
        // check row
        if (!isRectangleLegal(board, 0, 8, y, y, "Row"))
            return false;
 
        // Check block
        int x1 = x - x % 3;
        int y1 = y - y % 3;
        int x2 = x1 + 2;
        int y2 = y1 + 2;
        if (!RMSudoku2.isRectangleLegal(board, x1, x2, y1, y2, "Block"))
            return false;
 
        return true;
    }
 
    public static boolean solve(int[][] board) {
 
        // Find a position that's still empty.
        for (int x = 0; x < 9; x++) {
            for (int y = 0; y < 9; y++) {
                if (board[x][y] == 0) {
 
                    // Try each possibile value in this space
                    // and see if the rest of the puzzle can be filled in.
                    for (board[x][y] = 1; board[x][y] <= 9; board[x][y]++) {
                        if (isLegal(board, x, y) && solve(board)) {
                            return true;
                        }
                    }
 
                    // There is no value that we can put in the first
                    // empty space that was found, so the puzzle is
                    // unsolvable given the values put in up to this
                    // point.
                    board[x][y] = 0;
                    return false;
                }
            }
        }
 
        // There were no empty spaces to fill in, so the
        // puzzle must be solved.
        return true;
    }
 
    public static void printBoard(int[][] board) {
        for (int x = 0; x < 9; x++) {
            System.out.println(x % 3 == 0 ? "+-----+-----+-----+" : "|     |     |     |");
            for (int y = 0; y < 9; y++)
                System.out.print((y % 3 == 0 ? "|" : " ") + board[x][y]);
            System.out.println("|");
        }
        System.out.println("+-----+-----+-----+");
    }
 
    public static void main(String[] argv) {
 
        int board[][] = {
                {0, 0, 0, 0, 0, 0, 0, 1, 2},
                {0, 0, 0, 0, 5, 1, 3, 8, 0},
                {0, 8, 0, 0, 0, 6, 0, 0, 0},
 
                {1, 0, 0, 2, 4, 0, 0, 7, 0},
                {0, 0, 0, 0, 3, 0, 0, 0, 0},
                {0, 7, 0, 0, 6, 5, 0, 0, 3},
 
                {0, 0, 0, 4, 0, 0, 0, 2, 0},
                {0, 5, 9, 6, 8, 0, 0, 0, 0},
                {8, 1, 0, 0, 0, 0, 0, 0, 0}
        };
 
        long t1 = System.currentTimeMillis();
        if (solve(board))
            printBoard(board);
        else
            System.out.println("no solution");
        long t2 = System.currentTimeMillis();
        System.out.println(t2 - t1);
    }
}

The key difference is in isLegal(): rather than checking every single rule each time, the code now only checks the row, column, and block of the most-recently-added element. (All others have already been checked.) This results in about a factor of nine decrease in the number of checks to run, and shorter code with fewer "magic numbers" to boot.
[ October 31, 2006: Message edited by: Jim Yingst ]

[Jim Yingst]

And with further tweaking & refactoring to suit my own OO-design sensibilities (i.e. to convince myself this was my own work, not just piggybacking off Ryan, even though I was) , I got the execution time down to about 0.4 sec, and delivered the additional data that was part of my original motivation here (are there multiple solutions, and if so, what do they have in common?). Here's the code:

import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
 
public class Sudoku {
 
    private Board board;
 
    private final List<Board> solutions = new ArrayList<Board>();
 
    public static void solve(int[][] board) {
        new Sudoku(board).solve();
    }
 
    private Sudoku(int[][] arr) {
        board = new Board(arr);
    }
 
    private void solve() {
        solve(listEmptyPositions());
        int count = solutions.size();
        if (count == 0)
            System.out.println("no solution - invalid puzzle");
        else if (count == 1)
            System.out.println("unique solution - valid puzzle");
        else {
            System.out.println(count + " solutions - invalid puzzle");
            System.out.println("\ncommon part of all solutions:");
            findCommonSolution();
            board.show();
        }
    }
 
    private static class Position {
        final int x, y;
        Position next;
 
        Position(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
 
    private Position listEmptyPositions() {
        Position start = new Position(-1, -1);
        Position p = start;
        for (int x = 0; x < 9; x++) {
            for (int y = 0; y < 9; y++) {
                if (board.get(x, y) == 0) {
                    Position p2 = new Position(x, y);
                    p.next = p2;
                    p = p2;
                }
            }
        }
        return start.next;
    }
 
    private void solve(Position p) {
        // If no remaining empty space, puzzle is solved
        if (p == null) {
            foundSolution();
            return;
        }
 
        // Try all possibile values at this position
        int x = p.x;
        int y = p.y;
        for (int n = 1; n <= 9; n++) {
            board.set(x, y, n);
            if (isLegal(x, y))
                solve(p.next);
        }
        // reset
        board.set(x, y, 0);
    }
 
    private void foundSolution() {
        solutions.add(board.copy());
        board.show();
        return;
    }
 
    private boolean isLegal(int x, int y) {
        int n = board.get(x, y);
        return isLegalColumn(x, n) && isLegalRow(y, n) && isLegalBlock(x, y, n);
    }
 
    private boolean isLegalColumn(int x, int n) {
        boolean present = false;
        for (int j = 0; j < 9; j++) {
            if (board.get(x, j) == n) {
                if (present)
                    return false;
                present = true;
            }
        }
        return true;
    }
 
    private boolean isLegalRow(int y, int n) {
        boolean present = false;
        for (int i = 0; i < 9; i++) {
            if (board.get(i, y) == n) {
                if (present)
                    return false;
                present = true;
            }
        }
        return true;
    }
 
    private boolean isLegalBlock(int x, int y, int n) {
        boolean present = false;
        int x1 = x - (x % 3);
        int x2 = x1 + 3;
        int y1 = y - (y % 3);
        int y2 = y1 + 3;
 
        for (int i = x1; i < x2; i++) {
            for (int j = y1; j < y2; j++) {
                if (board.get(i, j) == n) {
                    if (present)
                        return false;
                    present = true;
                }
            }
        }
        return true;
    }
 
    public void findCommonSolution() {
        for (int i = 0; i < 9; i++)
            for (int j = 0; j < 9; j++)
                board.set(i, j, findCommonSolutionAt(i, j));
    }
 
    private int findCommonSolutionAt(int i, int j) {
        int c = 0;
        for (Board s : solutions) {
            int n = s.get(i, j);
            if (c == 0) {
                c = n;
            } else if (c != n) {
                c = 0;
                break;
            }
        }
        return c;
    }
 
    public static void main(String[] argv) {
 
        int board[][] = {
                {0, 0, 0, 0, 0, 0, 0, 1, 2},
                {0, 0, 0, 0, 5, 1, 3, 8, 0},
                {0, 8, 0, 0, 0, 6, 0, 0, 0},
                {1, 0, 0, 2, 4, 0, 0, 7, 0},
                {0, 0, 0, 0, 3, 0, 0, 0, 0},
                {0, 7, 0, 0, 6, 5, 0, 0, 3},
                {0, 0, 0, 4, 0, 0, 0, 2, 0},
                {0, 5, 9, 6, 8, 0, 0, 0, 0},
                {8, 1, 0, 0, 0, 0, 0, 0, 0}
        };
 
        long t1 = System.currentTimeMillis();
        solve(board);
        long t2 = System.currentTimeMillis();
        System.out.println(t2 - t1);
    }
}
 
class Board {
    private final int[] array = new int[81];
 
    private Board() { }
 
    public Board(int[][] values) {
        for (int i = 0; i < 9; i++)
            for (int j = 0; j < 9; j++)
                array[9 * j + i] = values[ i ][j];
    }
 
    public int get(int i, int j) { return array[9 * j + i]; }
 
    public void set(int i, int j, int n) { array[9 * j + i] = n; }
 
    public boolean equals(Object obj) {
        return obj instanceof Board && Arrays.equals(array, ((Board) obj).array);
    }
 
    public int hashCode() {
        return Arrays.hashCode(array);
    }
 
    public Board copy() {
        Board b = new Board();
        System.arraycopy(array, 0, b.array, 0, array.length);
        return b;
    }
 
    public void show() {
        for (int i = 0; i < 9; i++) {
            if (i % 3 == 0)
                System.out.println("+-----+-----+-----+");
            for (int j = 0; j < 9; j++) {
                System.out.print((j % 3 == 0 ? "|" : " "));
                int n = get(i, j);
                System.out.print(n == 0 ? " " : n);
            }
            System.out.println("|");
        }
        System.out.println("+-----+-----+-----+");
    }
}

Obviously that's a bit more verbose than the original, and many of the differences don't matter that much. But the net effect is faster.

In reality, I made RMSudoku2 (shown earlier) after the above code. After I'd gone through a number of revisions and learned what changes were most significant, I went back to Ryan's original and created RMSudoku2 as an alternate version that made just a few changes for maximum benefit, otherwise leaving the original unchanged (for easier comparison).

Also for what it's worth, here are two of the invalid boards with multiple solutions that motivated me in the first place:

        int board[][] = {
                {9, 0, 0, 1, 5, 0, 0, 6, 0},
                {0, 5, 1, 0, 6, 3, 4, 0, 0},
                {8, 0, 0, 7, 4, 0, 0, 0, 5},
                {1, 0, 9, 0, 8, 0, 5, 0, 0},
                {0, 2, 0, 3, 0, 7, 0, 4, 0},
                {0, 0, 3, 0, 2, 0, 9, 0, 8},
                {3, 0, 0, 0, 7, 9, 0, 0, 6},
                {0, 0, 4, 2, 3, 0, 7, 1, 0},
                {0, 9, 0, 0, 1, 0, 0, 0, 4},
        };
//        int board[][] = {
//                {0, 6, 4, 0, 9, 3, 0, 1, 0},
//                {1, 5, 3, 0, 0, 2, 0, 4, 0},
//                {0, 7, 0, 4, 0, 0, 0, 8, 3},
//                {5, 0, 0, 0, 2, 7, 1, 3, 0},
//                {2, 0, 1, 0, 0, 0, 7, 0, 9},
//                {0, 9, 8, 1, 3, 0, 0, 0, 2},
//                {3, 1, 0, 0, 0, 8, 0, 9, 0},
//                {0, 2, 0, 3, 0, 0, 8, 7, 4},
//                {0, 8, 0, 6, 7, 0, 3, 2, 0},
//        };

[ October 31, 2006: Message edited by: Jim Yingst ]