python轻松解决数独小游戏，结果通过递归获得最终答案

对于值域列表缩减函数进行了改造，增加了检测唯一值的方法，但最终我们依然没有得到答案，还有很多单元格的答案没有确定，应该怎么办呢？

 

在当前这种情况下，我们已经无法从数独中直接确定某个单元格的答案了，但是我们可以用测试的办法，去验证某个单元格的答案是哪一个值，我们以第7行第7列单元格为例，我们假设它的值是1，则这个变化会引起一系列的变化，最终我们得到这个：

 

在第二个九宫格出现了2个7，因此我们可以判断第7行第7列的值不是1，而应该是6。我们通过这种测试验证的方法获得了某个单元格的答案。我们现在需要用代码来实现：

# 主函数，输入值域列表，如遇到多个取值的单元格，依次尝试值域里的每个值，通过递归的方法检测值是否正确
def trial(total_value_range):
 for i in range(9):
 for j in range(9):
 if len(total_value_range[i][j]) > 1:
 for k in total_value_range[i][j]:
 test_value = copy.deepcopy(total_value_range)
 test_value[i][j] = [k]
 test_value = reduce_totalValueRange(generator_soduku(test_value))
 if soduku_checkRepeat(test_value):
 if sodukuRate(s_row_vrange) == 1:
 return s_row_vrange
 else: 
 if trial(test_value):
 return trial(test_value)
 else:
 continue
 else:
 continue
 return False

 

这段代码其实还是挺复杂的，容我细细解读：

# 主函数，输入值域列表，如遇到多个取值的单元格，依次尝试值域里的每个值，通过递归的方法检测值是否正确
def trial(total_value_range):
 for i in range(9):
 for j in range(9):
 if len(total_value_range[i][j]) > 1:
 for k in total_value_range[i][j]:
 test_value = copy.deepcopy(total_value_range)
 test_value[i][j] = [k]

• 我们设置i和j两个循环，是为了遍历total_value_range里的每一个元素当total_value_range[i][j] = 1时，也就是说这个单元格是已知单元格，取值已经确定了；如果total_value_range[i][j] > 1，这个单元格是未知单元格，值域列表有多个取值；对于未知单元格，我们遍历它的值域，同时拷贝一份total_value_range，并把值域里的值赋给test_value[i][j]，开始进行“试验”，看test_value[i][j]里的哪一个值是正确的；

# 检查行值域列表是否合法
def row_checkRepeat(s_value_range):
 for i in s_value_range:
 temp = []
 for j in i:
 if len(j) == 1:
 temp.append(j[0])
 len_temp = len(temp)
 if len_temp != len(list(set(temp))):
 return False
 return True
# 检查值域列表是否合法：行检测，列检测，九宫格检测
def soduku_checkRepeat(s_value_range):
 temp_col = list(zip(*s_value_range))
 temp_matrix = matrix_invert(s_value_range)
 return row_checkRepeat(s_value_range) and row_checkRepeat(temp_col) and row_checkRepeat(temp_matrix)
# 计算值域列表取值总的组合数（各单元格值域长度相乘）
def sodukuRate(s_row_vrange):
 rate = 1
 for i in s_row_vrange:
 for j in i:
 rate *= len(j)
 return rate
def trial(total_value_range):
 for i in range(9):
 for j in range(9):
 if len(total_value_range[i][j]) > 1:
 for k in total_value_range[i][j]:
 test_value = copy.deepcopy(total_value_range)
 test_value[i][j] = [k]
 test_value = reduce_totalValueRange(generator_soduku(test_value))
 if soduku_checkRepeat(test_value):
 if sodukuRate(test_value) == 1:
 return test_value
 else: 
 return trial(test_value)
 else:
 continue
 return False

• 赋值之后，我们立即使用之前的generator_soduku()和reduce_totalValueRange()方法，基于已有条件生成一个最新的值域列表；然后我们需要做的是，用soduku_checkRepeat()方法检验当前的值域列表是否合法，soduku_checkRepeat()方法的原理也很简单：首先我们写出一个检查行值域列表是否合法的函数：将一行已知单元格都选出放到一个列表里，检查列表是否有重复值；有了行值域检查函数，只需将数独进行行列转换和九宫格转换然后分别进行检测，如果三项检测均为True，则最后返回True，有一项False，最后返回False如果soduku_checkRepeat()显示当前值域列表合法，则使用sodukuRate()方法检测当前值域列表每个单元格是否都是已知单元格（各单元格值域长度均为1）若每个单元格值域长度均为1，则说明已经得到最终正确答案，则返回test_value，即最终正确答案；若sodukuRate(test_value)不为1，则说明经过一番操作后还未得到正确答案，或者得到错误答案，因此我们将当前的值域列表test_value作为参数，返回trial(test_value)，这个就用上了递归的概念，我们稍后详细解释；如果soduku_checkRepeat()显示当前值域列表不合法，则说明total_value_range[i][j]当前的取值k不正确，我们continue，继续循环；如果for k in total_value_range[i][j]，这个循环结束了，说明所有的取值k都是导向错误的结果（在第一层循环是不会出现的，会出现在第二层循环时），则返回False；

 

最终运行代码，得到了结果

PS D:\python\0624-soduku> python zhihutest2.py
[[5], [1], [4], [8], [9], [6], [3], [2], [7]]
[[7], [2], [6], [1], [3], [4], [9], [8], [5]]
[[3], [8], [9], [5], [7], [2], [4], [6], [1]]
[[8], [4], [7], [6], [1], [3], [5], [9], [2]]
[[1], [9], [5], [2], [4], [8], [7], [3], [6]]
[[6], [3], [2], [9], [5], [7], [8], [1], [4]]
[[2], [5], [3], [4], [8], [1], [6], [7], [9]]
[[4], [6], [8], [7], [2], [9], [1], [5], [3]]
[[9], [7], [1], [3], [6], [5], [2], [4], [8]]
代码执行完毕，用时0.04秒

把全部源码展示出来：

import copy
import time
# 求每一行单元格行值域
def valueRange(row):
 temp = copy.deepcopy(row)
 row_value_range = list(range(1,10))
 for i in row:
 if i == '':
 continue
 else:
 if row_value_range.count(i) > 0:
 row_value_range.remove(i)
 else:
 continue
 for j in range(9):
 if temp[j] == '':
 temp[j] = row_value_range
 else:
 temp[j] = [temp[j]]
 return temp
# 求数独每个单元格行值域
def rowValueRange(soduku):
 row_value_range = []
 for row in soduku:
 row_value_range.append(valueRange(row))
 return row_value_range
# 求数独每个单元格列值域
def colValueRange(soduku):
 soduku_invert = [list(i) for i in list(zip(*soduku))]
 temp = rowValueRange(soduku_invert)
 s_column_vrange = [list(i) for i in list(zip(*temp))]
 return s_column_vrange
# 将一个数独数组转化为数独九宫格数组
def matrix_invert(lista):
 listb = [[] for i in range(9)]
 for i in range(9):
 for j in range(9):
 k = i//3
 l = j//3
 m = k*3 + l
 listb[m].append(lista[i][j])
 return listb
# 求数独每个单元格九宫格值域
def matrixValueRange(soduku):
 matrix = matrix_invert(soduku)
 temp = rowValueRange(matrix)
 matrix_vrange = matrix_invert(temp)
 return matrix_vrange
# 三个列表求交集函数
def inersection(lista,listb,listc):
 tempa = []
 tempb = []
 for i in lista:
 for j in listb:
 if i == j:
 tempa.append(i)
 for k in listc:
 for l in tempa:
 if k == l:
 tempb.append(k)
 return tempb
# 求数独每个单元格总值域
def totalValueRange(soduku):
 row_value_range = rowValueRange(soduku)
 col_value_range = colValueRange(soduku)
 matrix_value_range = matrixValueRange(soduku)
 total_value_range = [[] for i in range(9)]
 for i in range(9):
 for j in range(9):
 total_value_range[i].append(inersection(row_value_range[i][j],col_value_range[i][j],matrix_value_range[i][j]))
 return total_value_range
# 寻找一行中唯一的值，若该值仅在行值域列表中出现了一次，则其所在单元格取值为该值
def checkUnique(list):
 listb = copy.deepcopy(list)
 templist = []
 for i in listb:
 templist.extend(i)
 for i in range(len(list)):
 for j in list[i]:
 if templist.count(j) == 1:
 listb[i] = [j]
 list = listb
 return list
# 寻找每一行的唯一值，更新值域列表
def row_checkUnique(s_row_vrange):
 temp = []
 for list in s_row_vrange:
 temp.append(checkUnique(list))
 s_row_vrange = temp
 return s_row_vrange
# 检查值域列表每一行、每一列、每一个九宫格的值域，并寻找唯一值，更新值域列表
def soduku_checkUnique(s_row_vrange):
 temp = []
 temp_b = []
 s_row_vrange = row_checkUnique(s_row_vrange)
 for i in list(zip(*s_row_vrange)):# 将数独进行行列转换，然后对每一列进行唯一值检测
 temp.append(list(i))
 temp = row_checkUnique(temp)
 for i in list(zip(*temp)):
 temp_b.append(list(i))
 temp_c = matrix_invert(temp_b)# 将数独进行九宫格转换，然后对每一九宫格进行唯一值检测
 temp_c = row_checkUnique(temp_c)
 temp_d = matrix_invert(temp_c)
 return temp_d
# 将获得的值域列表转化为一个新的数独题目
def generator_soduku(total_value_range):
 soduku = [[] for i in range(9)]
 for i in range(9):
 for j in range(9):
 if len(total_value_range[i][j]) == 1:
 soduku[i].append(total_value_range[i][j][0])
 else:
 soduku[i].append('')
 return soduku
# 值域列表缩减函数：将值域列表转化为数独题目，求新的数独题目的值域列表，如此反复
def reduce_totalValueRange(soduku):
 for n in range(100):
 total_value_range = totalValueRange(soduku)
 total_value_range = soduku_checkUnique(total_value_range)
 soduku = generator_soduku(total_value_range)
 if total_value_range == totalValueRange(generator_soduku(total_value_range)):
 break
 return total_value_range
# 检查行值域列表是否合法
def row_checkRepeat(s_value_range):
 for i in s_value_range:
 temp = []
 for j in i:
 if len(j) == 1:
 temp.append(j[0])
 len_temp = len(temp)
 if len_temp != len(list(set(temp))):
 return False
 return True
# 检查值域列表是否合法：行检测，列检测，九宫格检测
def soduku_checkRepeat(s_value_range):
 temp_col = list(zip(*s_value_range))
 temp_matrix = matrix_invert(s_value_range)
 return row_checkRepeat(s_value_range) and row_checkRepeat(temp_col) and row_checkRepeat(temp_matrix)
# 计算值域列表取值总的组合数（各单元格值域长度相乘）
def sodukuRate(s_row_vrange):
 rate = 1
 for i in s_row_vrange:
 for j in i:
 rate *= len(j)
 return rate
# 主函数，输入值域列表，如遇到多个取值的单元格，依次尝试值域里的每个值，通过递归的方法检测值是否正确
def trial(total_value_range):
 for i in range(9):
 for j in range(9):
 if len(total_value_range[i][j]) > 1:
 for k in total_value_range[i][j]:
 test_value = copy.deepcopy(total_value_range)
 test_value[i][j] = [k]
 test_value = reduce_totalValueRange(generator_soduku(test_value))
 if soduku_checkRepeat(test_value):
 if sodukuRate(test_value) == 1:
 return test_value
 else: 
 return trial(test_value)
 else:
 continue
 return False
if __name__ == '__main__':
 t1 = time.time()
 soduku = [[] for i in range(9)]
 soduku[0] = ['',1,4,'',9,'','',2,'']
 soduku[1] = ['','','','',3,'','','',5]
 soduku[2] = [3,8,'','','',2,'',6,'']
 soduku[3] = [8,4,'',6,'','','','',2]
 soduku[4] = [1,'',5,2,'','',7,'','']
 soduku[5] = ['','','','','',7,8,'','']
 soduku[6] = [2,'','',4,'','','','',9]
 soduku[7] = ['',6,'','','',9,'',5,'']
 soduku[8] = ['','','','','','','','','']
 a = reduce_totalValueRange(soduku)
 for i in trial(a):
 print(i)
 print("代码执行完毕，用时{}秒".format(round(time.time() - t1,2)))

最后多说一句，小编是一名python开发工程师，这里有我自己整理了一套最新的python系统学习教程，包括从基础的python脚本到web开发、爬虫、数据分析、数据可视化、机器学习等。想要这些资料的可以关注小编，并在点击：“资料   即可领取。