finish Problem 37

完成了README，重构了程序

Author: aQua

Algorithms/0037.sudoku-solver/README.md

@@ -17,8 +17,16 @@ A sudoku puzzle...
 
 ## 解题思路
 我把数独框中，需要保证数字不重复的3×3小块，称为一个block。
-由于数独需要保持每行，每列，每个block中的数字不重复。
-
+由于数独需要保持每行，每列，每个block中的数字不重复。解题思路如下：
+1. 依次往9个block中，分别填写1~9。
+1. 如果block中已经存在n了，去填写下一个数。
+1. 在可行的空位填好 n 后
+    1. 如果后面的填写没有问题，返回true
+    1. 如果后面的填写有问题，把n移入下一个可行的位置。
+        1. n在这个block中，没有位置放了，返回false
+1. 1～9都填写完了，就去填写下一个block分别填写1～9
+1. 所有的block都填写完了，结束。
+
+具体过程和细节，见程序及注释。
 ## 总结
-
-
+虽然，我一直主张编写不超过20行的函数，但是匿名函数确实好用。

Algorithms/0037.sudoku-solver/sudoku-solver.go

@@ -1,69 +1,72 @@
 package Problem0037
 
 func solveSudoku(board [][]byte) {
-	nums := []byte("123456789")
-	blocks := []int{0, 1, 2, 3, 4, 5, 6, 7, 8}
-
-	if !fillBlock(board, nums, blocks) {
+	if !fill(board, '1', 0) {
 		panic("此题无解")
 	}
 }
 
-func fillBlock(board [][]byte, nums []byte, blocks []int) bool {
-	if len(blocks) == 0 {
+func fill(board [][]byte, n byte, block int) bool {
+	if block == 9 {
+		// 所有的block都已经填满，成功找到了解
 		return true
 	}
-	if len(nums) == 0 {
-		return fillBlock(board, []byte("123456789"), blocks[1:])
-	}
 
-	block := blocks[0]
-	n := nums[0]
-	nums = nums[1:]
+	if n == '9'+1 {
+		// 此 block 已经被填满了，去填写下一个 block
+		return fill(board, '1', block+1)
+	}
 
 	// print(board, n, block)
 
-	rowZero := (block / 3) * 3
-	colZero := (block % 3) * 3
+	rowBegin := (block / 3) * 3
+	colBegin := (block % 3) * 3
 
-	// 检查block中，是否已经存在 b 了
-	had := func() bool {
-		for r := rowZero; r < rowZero+3; r++ {
-			for c := colZero; c < colZero+3; c++ {
-				if board[r][c] == n {
-					return true
-				}
+	for r := rowBegin; r < rowBegin+3; r++ {
+		for c := colBegin; c < colBegin+3; c++ {
+			if board[r][c] == n {
+				// block 中已经有 n 了，无需填写
+				// 去填写下一个 n
+				return fill(board, n+1, block)
 			}
 		}
-		return false
 	}
 
-	if had() {
-		return fillBlock(board, nums, blocks)
-	}
-	// 检查(r,c)所在的行和列是否已经存在 n 了
-	isClear := func(r, c int) bool {
+	// 检查 (r,c) 能否存放 n
+	// 使用匿名函数，避免传递参数
+	isAvaliable := func(r, c int) bool {
+		// 当前位置上的字符需为 '.'
+		if board[r][c] != '.' {
+			return false
+		}
+
+		// (r,c) 所在的行和列不能有 n
+		// 在这里就可以体现，挨个往block中填写的优势了。
 		for i := 0; i < 9; i++ {
 			if board[r][i] == n || board[i][c] == n {
 				return false
 			}
 		}
+
 		return true
 	}
 
-	for r := rowZero; r < rowZero+3; r++ {
-		for c := colZero; c < colZero+3; c++ {
-			if board[r][c] == '.' && isClear(r, c) {
+	for r := rowBegin; r < rowBegin+3; r++ {
+		for c := colBegin; c < colBegin+3; c++ {
+			if isAvaliable(r, c) {
 				board[r][c] = n
-				if fillBlock(board, nums, blocks) {
+				if fill(board, n+1, block) {
 					return true
 				}
-				// 后面的填写不成功，所以需要还原这个格子
+
+				// 把 (r,c) 还原，把 n 移入下一个可行的位置
 				board[r][c] = '.'
+
 				// print(board, n, block)
 			}
 		}
 	}
-
+	// n 在此 block 中无处可放。
+	// 返回 false ，让前一个 n 调整位置。
 	return false
 }

Algorithms/0037.sudoku-solver/sudoku-solver_test.go

@@ -64,6 +64,45 @@ func Test_Problem0036(t *testing.T) {
 		ast.Equal(a.one, p.one, "输入:%v", p)
 	}
 }
+func Test_Panic(t *testing.T) {
+	ast := assert.New(t)
+
+	qs := []question{
+
+		question{
+			para{[][]byte{
+				[]byte("..9748..."),
+				[]byte("7....8..."),
+				[]byte(".2.1.9..."),
+				[]byte("..7...24."),
+				[]byte(".64.1.59."),
+				[]byte(".98...3.."),
+				[]byte("...8.3.2."),
+				[]byte("........6"),
+				[]byte("...2759.."),
+			}},
+			ans{[][]byte{
+				[]byte("519748632"),
+				[]byte("783652419"),
+				[]byte("426139875"),
+				[]byte("357986241"),
+				[]byte("264317598"),
+				[]byte("198524367"),
+				[]byte("975863124"),
+				[]byte("832491756"),
+				[]byte("641275983"),
+			}},
+		},
+
+		// 如需多个测试，可以复制上方元素。
+	}
+
+	for _, q := range qs {
+		p := q.para
+		fmt.Printf("~~%v~~\n", p)
+		ast.Panics(func() { solveSudoku(p.one) }, "输入:%v", p)
+	}
+}
 
 func print(board [][]byte, b byte, block int) {
 	fmt.Printf("\n====fill %d in block %d ====", b-'0', block)