python数独代码九宫格

原创

mob64ca12d61d6b 2024-11-01 05:40:40 ©著作权

©著作权归作者所有：来自51CTO博客作者mob64ca12d61d6b的原创作品，请联系作者获取转载授权，否则将追究法律责任

实现一个Python数独代码九宫格

数独游戏是一种经典的逻辑推理游戏，通常由9x9的网格组成，其中的数字1到9需要填入这些格子中，保证每一行、每一列和每一个3x3的小格子内的数字都是唯一的。本文将带你了解如何用Python编写一个简单的数独解决方案，并展示九宫格。

流程概述

实现数独的整体流程可以分为以下几个步骤：

| 步骤序号 | 步骤描述           |
|----------|-------------------|
| 1        | 初始化数独矩阵    |
| 2        | 定义函数，检查合法性 |
| 3        | 定义函数，寻找空格  |
| 4        | 递归回溯算法实现   |
| 5        | 输出最终结果        |
| 6        | 可视化数独九宫格   |

接下来，我们将逐步实现这些步骤。

1. 初始化数独矩阵

在Python中，我们用一个二维列表来表示9x9的数独矩阵。以下是初始化默认数独矩阵的代码：

# 初始化一个9x9的数独矩阵
def create_board():
    # 使用0初始化空格，0代表空格，其他数字代表已经填入的数字
    board = [
        [5, 3, 0, 0, 7, 0, 0, 0, 0],
        [6, 0, 0, 1, 9, 5, 0, 0, 0],
        [0, 9, 8, 0, 0, 0, 0, 6, 0],
        [8, 0, 0, 0, 6, 0, 0, 0, 3],
        [4, 0, 0, 8, 0, 3, 0, 0, 1],
        [7, 0, 0, 0, 2, 0, 0, 0, 6],
        [0, 6, 0, 0, 0, 0, 2, 8, 0],
        [0, 0, 0, 4, 1, 9, 0, 0, 5],
        [0, 0, 0, 0, 8, 0, 0, 7, 9]
    ]
    return board

2. 定义函数，检查合法性

我们需要一个函数来检查数字填入某个位置时，是否合法。即同一行、同一列和同一个3x3小格子中不能有重复的数字。

def is_valid(board, row, col, num):
    # 检查行
    for c in range(9):
        if board[row][c] == num:
            return False
    
    # 检查列
    for r in range(9):
        if board[r][col] == num:
            return False
    
    # 检查3x3小格子
    box_row, box_col = row // 3 * 3, col // 3 * 3
    for r in range(box_row, box_row + 3):
        for c in range(box_col, box_col + 3):
            if board[r][c] == num:
                return False
    return True

3. 定义函数，寻找空格

我们需要一个函数来寻找下一个空的位置，函数返回一个元组，代表空白的位置。

def find_empty(board):
    for r in range(9):
        for c in range(9):
            if board[r][c] == 0:
                return (r, c)  # 返回空位的行和列
    return None  # 如果没找到，返回None

4. 递归回溯算法实现

我们现在可以使用递归回溯算法来解决数独。这个算法的思想是尝试填入数字，如果填入后不合法，就撤销这个选择并尝试其他数字。

def solve_sudoku(board):
    empty = find_empty(board)
    if not empty:
        return True  # 没有空位，数独已解决

    row, col = empty
    for num in range(1, 10):  # 数字从1到9
        if is_valid(board, row, col, num):
            board[row][col] = num  # 填入数字

            if solve_sudoku(board):
                return True  # 解算成功

            board[row][col] = 0  # 撤销选择

    return False  # 这条路径无解，返回False

5. 输出最终结果

输入后的数独能够进行求解，最后输出结果。

def print_board(board):
    for row in board:
        print(" ".join(str(num) if num != 0 else '.' for num in row))

6. 可视化数独九宫格

为了让结果更清晰，我们可以用文本形式来表示数独的九宫格。

def display_sudoku(board):
    print("数独结果：")
    for i in range(9):
        if i % 3 == 0 and i != 0:
            print("- - - - - - - - - - - - ")
        for j in range(9):
            if j % 3 == 0 and j != 0:
                print("| ", end="")
            print(board[i][j], end=" ")
        print()

运行完整程序

将以上函数整合，运行我们的数独解决方案：

if __name__ == "__main__":
    sudoku_board = create_board()
    if solve_sudoku(sudoku_board):
        display_sudoku(sudoku_board)
    else:
        print("无解")

类图

以下是我们在实现数独过程中涉及到的类的结构示意图：

classDiagram
class SudokuSolver {
    + create_board() : list
    + is_valid(board: list, row: int, col: int, num: int) : bool
    + find_empty(board: list) : tuple
    + solve_sudoku(board: list) : bool
    + print_board(board: list)
    + display_sudoku(board: list)
}