使用Python求解數獨

之前學習xlrd和xlwt模塊的時候，突發奇想，能不能用Python寫個求解數獨的小程序呢？然後找找資料，在實驗樓上發現了現成的例子，然後花了一晚上，改動了一部分，自己寫了一遍。（這裏的數獨並不滿足對角線原則，試了下，把對角線的要求加進去，通過這種方法生成一個數獨太耗時間了，你們要是有興趣，可以改進下這裏）
直接上程序吧，下次有空過來整理整理。

import random
import itertools
from copy import deepcopy

test = [[None, None, 3, None, 6, 9, None, 1, 7],
        [None, 1, None, 2, 4, 8, None, None, 9],
        [4, None, 9, 7, 1, None, None, 2, 6],
        [9, 7, 2, 1, 8, 4, 6, 3, 5],
        [1, None, 8, None, 5, 2, 7, 9, 4],
        [6, 4, 5, 9, 3, 7, None, None, None],
        [None, 9, None, 4, None, None, 2, None, 8],
        [None, 6, None, 8, None, 1, None, 4, 3],
        [None, None, None, None, None, None, 5, 7, 1]]
'''
+++&&&&&++&&&&&++&&&&&+++&&&&&++&&&&&++&&&&&+++&&&&&++&&&&&++&&&&&+++
&&&     ||     ||  3  &&&     ||  6  ||  9  &&&     ||  1  ||  7  &&&
+++-----++-----++-----+++-----++-----++-----+++-----++-----++-----+++
&&&     ||  1  ||     &&&  2  ||  4  ||  8  &&&     ||     ||  9  &&&
+++-----++-----++-----+++-----++-----++-----+++-----++-----++-----+++
&&&  4  ||     ||  9  &&&  7  ||  1  ||     &&&     ||  2  ||  6  &&&
+++&&&&&++&&&&&++&&&&&+++&&&&&++&&&&&++&&&&&+++&&&&&++&&&&&++&&&&&+++
&&&  9  ||  7  ||  2  &&&  1  ||  8  ||  4  &&&  6  ||  3  ||  5  &&&
+++-----++-----++-----+++-----++-----++-----+++-----++-----++-----+++
&&&  1  ||     ||  8  &&&     ||  5  ||  2  &&&  7  ||  9  ||  4  &&&
+++-----++-----++-----+++-----++-----++-----+++-----++-----++-----+++
&&&  6  ||  4  ||  5  &&&  9  ||  3  ||  7  &&&     ||     ||     &&&
+++&&&&&++&&&&&++&&&&&+++&&&&&++&&&&&++&&&&&+++&&&&&++&&&&&++&&&&&+++
&&&     ||  9  ||     &&&  4  ||     ||     &&&  2  ||     ||  8  &&&
+++-----++-----++-----+++-----++-----++-----+++-----++-----++-----+++
&&&     ||  6  ||     &&&  8  ||     ||  1  &&&     ||  4  ||  3  &&&
+++-----++-----++-----+++-----++-----++-----+++-----++-----++-----+++
&&&     ||     ||     &&&     ||     ||     &&&  5  ||  7  ||  1  &&&
+++&&&&&++&&&&&++&&&&&+++&&&&&++&&&&&++&&&&&+++&&&&&++&&&&&++&&&&&+++'''

def full_board():
    board = None

    while board is None:
        board = attmpt_board()
    return board

def attmpt_board():
    nums = list(range(1,10))
    board = [[None for _ in range(9)] for _ in range(9)]

    for i,j in itertools.product(range(9),repeat=2):#這個函數可以將兩層甚至多層循環簡寫一下
        i0,j0 = i - i % 3,j - j % 3
        random.shuffle(nums)
        for x in nums:
            if(x not in board[i]
            and all(x != row[j] for row in board)
            and all(x not in row[j0:j0 + 3] for row in board[i0:i])):
                board[i][j] = x
                break
        else:
            return None
    return board

def get_board(full_board,level=1): #難度等級

    board = deepcopy(full_board)
    omit = [0,35,60,81] #挖出的方塊數，因爲隨機挖的時候可能重複挖到某個，所以一般小於該數

    for _ in range(omit[level]):
        i = random.randint(0,8) #隨機取0——8中的一個數
        j = random.randint(0,8)
        board[i][j] = None
    return board

def print_board(board):
    spacer = '+++-----++-----++-----+++-----++-----++-----+++-----++-----++-----+++'

    for i in range(9):
        if i % 3 ==0:
            print(spacer.replace('-','&'))
        else:
            print(spacer)
        print('&&&  {}  ||  {}  ||  {}  &&&  {}  ||  {}  ||  {}  &&&  {}  ||  {}  ||  {}  &&&'
            .format(*(cell or ' ' for cell in board[i])))
    print(spacer.replace('-','&'))

def isfull(board):
    for i,j in itertools.product(range(9),repeat=2):
        if board[i][j] == None:
            return False
    return True

def list_cell(board,x,y): #返回某個空格可以填入的數字的列表
    nums = set(range(1,10))
    row = set(board[x]) #所在的行已有的數字
    col = set(row[y] for row in board) #列
    x0,y0 = x - x % 3,y - y % 3
    block = set(board[i][j] for i,j in itertools.product(range(x0,x0+3),range(y0,y0+3))) #塊

    result = nums - row - col - block
    return list(result)

def min_pos(board): #返回最短的可填列表所在的座標
    min_,x,y = 9,-1,-1
    for i,j in itertools.product(range(9),repeat=2):
        if board[i][j] == None:
            temp = len(list_cell(board,i,j))
            if temp < min_:
                min_ = temp
                x,y = i,j
    return x,y

def next_pos(x,y): #返回下個位置的座標
    pos = 9 * x + y
    x = ((pos+1) % 81)//9
    y = (pos+1) % 9
    return x,y

def solve_board(board):
    if isfull(board):
        return board

    while True:
        x,y = min_pos(board)
        nums = list_cell(board,x,y)
        if len(nums) == 1:
            board[x][y] = nums[0]
        else:
            break

    x,y = min_pos(board)
    result = core_fun(board,x,y)
    return result

def core_fun(board,x,y):
    if isfull(board):
        return board

    while board[x][y]:
        x,y = next_pos(x,y)

    numbers = list_cell(board,x,y)

    if len(numbers) == 0:
        return False

    for num in numbers:
        board[x][y] = num
        flag = core_fun(board,next_pos(x,y)[0],next_pos(x,y)[1])#一直往下遞歸
        if flag == False: #遞歸到某個空任何數都不能填進去的時候
            board[x][y] = None #因爲上一步操作是讓board[x][y]=n，表明賦值爲n是不對的。接着往下走，取numbers中的下一個數
        else:
            return board #board不斷的在改變,直到求解出答案

    #這裏不好理解，這表明numbers中的所有數據用完了，還不對，怎麼可能呢？
    #通過上面的numbers = list_cell(board,x,y)算出來的numbers肯定是對的啊。所以肯定到不了這一步啊
    #其實吧，因爲這裏有遞歸，當前層的numbers是在上一層選了一個數字之後得出的，有可能上一層選的數字就不對
    #所以這裏試將上一層的那個錯誤的數置爲空
    board[x][y] = None
    return False

FullBoard = full_board()
print('fullboard:\n')
print_board(FullBoard)
print()
my_board = get_board(FullBoard,3)
print('my_board:\n')
print_board(my_board)

result = solve_board(my_board)
print('\nanswer:\n')
print_board(result)

運行截圖



（可見，數獨的答案可能並不唯一，下次試試求解所有的滿足要求的答案）