旁友数独会伐啦？python秒解数独了解下伐啦？

时间  2019-11-12
标签 数独 python 解下 栏目 Python 繁體版
原文   原文链接

在这里插入图片描述

前几天和隔壁邻居玩斗地主被发现了，牌被没收了，斗地主是斗不了了，但我还想和邻居玩耍。若是你还想斗斗地主，戳：趁老王不在，和隔壁邻居斗斗地主，比比大小python

想破脑壳终于让我想到一个游戏，数独！什么叫数独？数独就是可让我趁老王不在的时候和隔壁邻居一块儿玩耍的游戏！git

在这里插入图片描述

数独的规则

一、数字 1-9 在每一行只能出现一次。github

二、数字 1-9 在每一列只能出现一次。windows

三、数字 1-9 在每个 3x3 宫内只能出现一次。3x3 的宫内为A1-C3,A4-C6,A7-C9,D1-F3,D4-F6,D7-F9...数组

数独题目示例

在这里插入图片描述

大体思路

一、数独咱们使用一个二维列表存储,没有值的位置咱们使用''空字符窜占位。（二维数组）app

二、获得每个3*3的宫内,每一行，每一列已有的数据，而后存放起来。三、获得全部的空缺位置，再遍历空缺位置，尝试放置数据，而后进行判断，若是知足条件安继续放置下一个。以此类推，在途中有不知足条件的状况，就进行回溯，返回上一次知足条件的状况，在进行另外一次尝试。编辑器

在这里插入图片描述

演示环境

  • 操做系统：windows10
  • python版本：python 3.7
  • 代码编辑器：pycharm 2018.2

具体代码

一、首选咱们建立一个类SudoKu。编写构造函数。函数

class SudoKu():
    def __init__(self,sudo_ku_data):
        # 判断传入的数独是否知足格式
        if not isinstance(sudo_ku_data,list):
            raise TypeError(f'sudo_ku_data params must a list, but {sudo_ku_data} is a {type(sudo_ku_data)}')

        if len(sudo_ku_data) != 9 or len(sudo_ku_data[0]) != 9:
            raise TypeError(f'sudo_ku_data params must a 9*9 list, but {sudo_ku_data} is a {len(sudo_ku_data)}*{len(sudo_ku_data[0])} list')

        self.sudo_ku = sudo_ku_data
        # 存放每一行已有的数据
        self.every_row_data = {}
        # 每一列已有的数字
        self.every_column_data = {}
        # 每个3*3宫内有的数字
        self.every_three_to_three_data = {}
        # 每个空缺的位置
        self.vacant_position = []
        # 每个空缺位置尝试了的数字
        self.every_vacant_position_tried_values = {}

二、编写添加每一行，每一列，每一宫方法，方便咱们后面调用测试

def _add_row_data(self,row,value):
    '''
    添加数据到self.every_row_data中,即对每一行已有的数据进行添加
    :param row:
    :param value:
    :return:
    '''
    # 若是当前行不存在，就以当前行为key，初始化值为set()（空的集合）
    if row not in self.every_row_data:
        self.every_row_data[row] = set()

    # 若是这个值已经出现过在这一行了，说明传入的不是一个正确的数独
    if value in self.every_row_data[row]:
        raise TypeError(f'params {self.sudo_ku} is a invalid SudoKu')

    self.every_row_data[row].add(value)

def _add_column_data(self,column,value):
    '''
    添加数据到self.every_column_data中,上面的函数思路同样
    :param column:
    :param value:
    :return:
    '''
    if column not in self.every_column_data:
        self.every_column_data[column] = set()

    if value in self.every_column_data[column]:
        raise TypeError(f'params {self.sudo_ku} is a invalid SudoKu')

    self.every_column_data[column].add(value)

def _get_three_to_three_key(self,row,column):
    '''
    获得该位置在哪个3*3的宫内
    :param row:
    :param column:
    :return:
    '''
    if row in [0,1,2]:
        if column in [0,1,2]:
            key = 1
        elif column in [3,4,5]:
            key = 2
        else:
            key = 3
    elif row in [3,4,5]:
        if column in [0,1,2]:
            key = 4
        elif column in [3,4,5]:
            key = 5
        else:
            key = 6
    else:
        if column in [0,1,2]:
            key = 7
        elif column in [3,4,5]:
            key = 8
        else:
            key = 9

    return key

def _add_three_to_three_data(self,row,column,value):
    '''
    添加数据到self.every_three_to_three_data中
    :param row:
    :param column:
    :param value:
    :return:
    '''
    # 首先获得在哪个3*3的宫内
    key = self._get_three_to_three_key(row,column)

    # 而后也和上面添加行，列的思路同样
    if key not in self.every_three_to_three_data:
        self.every_three_to_three_data[key] = set()

    if value in self.every_three_to_three_data[key]:
        raise TypeError(f'params {self.sudo_ku} is a invalid SudoKu')

    self.every_three_to_three_data[key].add(value)

三、遍历数独，对每种数据进行初始化操作系统

def _init(self):
    '''
    根据传入的数独，初始化数据
    :return:
    '''
    for row,row_datas in enumerate(self.sudo_ku):
        for column,value in enumerate(row_datas):
            if value == '':
                # 添加空缺位置
                self.vacant_position.append( (row,column) )
            else:
                # 添加行数据
                self._add_row_data(row,value)
                # 添加列数据
                self._add_column_data(column,value)
                # 添加宫数据
                self._add_three_to_three_data(row,column,value)

四、编写判断某一个位置的值是否合法的函数

def _judge_value_is_legal(self,row,column,value):
    '''
    判断方放置的数据是否合法
    :param row:
    :param column:
    :param value:
    :return:
    '''

    # value是否存在这一行数据中
    if value in self.every_row_data[row]:
        return False
    # value是否存在这一列数据中
    if value in self.every_column_data[column]:
        return False

    # value是否存在这个3*3的宫内
    key = self._get_three_to_three_key(row,column)
    if value in self.every_three_to_three_data[key]:
        return False

    return True

五、编写计算的函数，在当前位置循环 可使用的额数据，肯定能够是否能够放置这个值

def _calculate(self, vacant_position):
    '''
    计算，开始对数独进行放置值
    :param vacant_position:
    :return:
    '''
    # 获得当前位置
    row,column = vacant_position
    values = set(range(1,10))

    # 对当前为位置建立一个惟一key,用来存放当前位置已经尝试了的数据
    key = str(row) + str(column)
    # 若是这个key存在，就对values进行取差集，由于两个都是集合（set），直接使用-就好了
    if key in self.every_vacant_position_tried_values:
        values = values - self.every_vacant_position_tried_values[key]
    # 若是这个key不存在，就建立一个空的集合
    else:
        self.every_vacant_position_tried_values[key] = set()

    for value in values:
        # 对当前数据添加到当前位置尝试过的的数据中
        self.every_vacant_position_tried_values[key].add(value)
        # 若是当前value合法，能够放置
        if self._judge_value_is_legal(row,column,value):
            print(f'set {vacant_position} value is {value}')
            # 更新 判断数据合法时 须要使用到的数据
            self.every_column_data[column].add(value)
            self.every_row_data[row].add(value)
            key = self._get_three_to_three_key(row,column)
            self.every_three_to_three_data[key].add(value)

            # 修改这个位置的值为value
            self.sudo_ku[row][column] = value
            # 返回True 和填充的 value
            return True,value

    return False,None

六、若是当前位置没有任何一个值能够放置，那么就回溯，返回上一次成功的位置，从新取值,因此咱们编写一个回溯函数

def _backtrack(self,current_vacant_position,previous_vacant_position,previous_value):
    '''
    回溯
    :param current_vacant_position: 当前尝试失败的位置
    :param previous_vacant_position: 上一次成功的位置
    :param previous_value:上一次成功的值
    :return:
    '''
    print(f"run backtracking... value is {previous_value},vacant position is {previous_vacant_position}")
    row,column = previous_vacant_position
    # 对上一次成功的值从须要用到的判断的数据中移除
    self.every_column_data[column].remove(previous_value)
    self.every_row_data[row].remove(previous_value)

    key = self._get_three_to_three_key(row,column)
    self.every_three_to_three_data[key].remove(previous_value)

    # 而且上一次改变的的值变回去
    self.sudo_ku[row][column] = ''

    # 对当前尝试失败的位置已经城市失败的的值进行删除，由于回溯了，因此下一次进来须要从新判断值
    current_row,current_column = current_vacant_position
    key = str(current_row) + str(current_column)
    self.every_vacant_position_tried_values.pop(key)

七、到这里为止，咱们全部的功能函数都写完了，而后咱们编写一个函数，开始循环全部的空缺位置。而后进行计算。

def get_result(self):
    '''
    获得计算以后的数独
    :return:
    '''

    # 首先初始化一下数据
    self._init()

    # 空缺位置的长度
    length = len(self.vacant_position)
    # 空缺位置的下标
    index = 0

    # 存放已经尝试了的数据
    tried_values = []
    # 若是index小于length,说明尚未计算完
    while index < length:
        # 获得一个空缺位置
        vacant_position = self.vacant_position[index]

        # 计入计算函数，返回是否成功，若是成功，value为成功 的值，若是失败，value为None
        is_success,value = self._calculate(vacant_position)
        # 若是成功，将value放在tried_values列表里面，由于列表是有序的.
        # index+1 对下一个位置进行尝试
        if is_success:
            tried_values.append(value)
            index += 1
        # 失败，进行回溯,而且index-1，返回上一次的空缺位置，咱们须要传入当前失败的位置 和 上一次成功的位置和值
        else:
            self._backtrack(vacant_position,self.vacant_position[index-1],tried_values.pop())
            index -= 1

        # 若是index<0 了 说明这个数独是无效的
        if index < 0:
            raise ValueError(f'{self.sudo_ku} is a invalid sudo ku')

    # 返回计算以后的数独
    return self.sudo_ku

效果展现

呼。。。终于干完代码，接下来咱们呢能够"开始收获"了

if __name__ == '__main__':
    sudo_ku_data = [
        [5,3,'','',7,'','','',''],
        [6,'','',1,9,5,'','',''],
        ['',9,8,'','','','',6,''],
        [8,'','','',6,'','','',3],
        [4,'','',8,'',3,'','',1],
        [7,'','','',2,'','','',6],
        ['',6,'','','','',2,8,''],
        ['','','',4,1,9,'','',5],
        ['','','','',8,'','',7,9],
    ]

    # 获得计算好的数独
    sudo_ku = SudoKu(sudo_ku_data).get_result()
    print(sudo_ku)

################
#   结果显示    #
################
[5, 3, 4, 6, 7, 8, 9, 1, 2]
[6, 7, 2, 1, 9, 5, 3, 4, 8]
[1, 9, 8, 3, 4, 2, 5, 6, 7]
[8, 5, 9, 7, 6, 1, 4, 2, 3]
[4, 2, 6, 8, 5, 3, 7, 9, 1]
[7, 1, 3, 9, 2, 4, 8, 5, 6]
[9, 6, 1, 5, 3, 7, 2, 8, 4]
[2, 8, 7, 4, 1, 9, 6, 3, 5]
[3, 4, 5, 2, 8, 6, 1, 7, 9]

这效果就很完美啊，咱们在来测试一个比较可贵数独。

输入数独为：

[
    [8, '', '', '', '', '', '', '', 4],
    ['', 2, '', '', '', '', '', 7, ''],
    ['', '', 9, 1, '', 6, 5, '', ''],
    ['', '', 6, 2, '', 8, 9, '', ''],
    ['', 9, '', '', 3, '', '', 4, ''],
    ['', '', 2, 4, '', 7, 8, '', ''],
    ['', '', 7, 9, '', 5, 6, '', ''],
    ['', 8, '', '', '', '', '', 2, ''],
    [6, '', '', '', '', '', '', '', 9],
]

################
#   结果显示    #
################
[8, 6, 1, 5, 7, 2, 3, 9, 4]
[5, 2, 4, 3, 8, 9, 1, 7, 6]
[3, 7, 9, 1, 4, 6, 5, 8, 2]
[4, 3, 6, 2, 5, 8, 9, 1, 7]
[7, 9, 8, 6, 3, 1, 2, 4, 5]
[1, 5, 2, 4, 9, 7, 8, 6, 3]
[2, 4, 7, 9, 1, 5, 6, 3, 8]
[9, 8, 5, 7, 6, 3, 4, 2, 1]
[6, 1, 3, 8, 2, 4, 7, 5, 9]

哈哈哈哈哈，之后还有谁可以和我比解数独。膨胀.jpg

代码已所有上传至Github：https://github.com/MiracleYoung/You-are-Pythonista/tree/master/PythonExercise/App/solveSudoku/xujin

更多好玩有趣的Python尽请关注「Python专栏」

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程