[Python]推算数独

最新推荐文章于 2024-10-14 23:40:45 发布
最新推荐文章于 2024-10-14 23:40:45 发布
阅读量112 收藏 1
点赞数
文章标签： python
原文链接：https://my.oschina.net/KavenFan/blog/83170
版权

写了一段推算数独的代码，虽然很粗糙，但能解大部分的数独。（囧，有时候会解决不出，有时候还会出错，目前还没有仔细审核。现在就将就着备份在这里吧，虽然极其地不负责任~~~）

#-*- coding:utf8 -*-

import sys

data_list = [
#'''
#-69-1--3-
#--79-----
#---84---6
#---3--1--
#53--7--48
#--2--8---
#6---23---
#-----15--
#-1--8-47-
#''',
'''
3--------
---------
---------
---------
---------
---------
---------
---------
---------
''',
##very hard
#'''
#4-----1--
#7--1-5-4-
#---34-2--
#-1-42---5
#2-3-8-4-9
#8---53-1-
#--8-16---
#-7-8-4--1
#--9-----4
#''',
#    
#'''
#--9----4-
#---23-6-1
#-3---6--2
#----14-76
#--6-8-4--
#45-76----
#6--8---5-
#8-7-59---
#-2----8--
#''',
#    
#
#'''
#-----5-7-
#2--3-95-1
#15--2---9
#--8-63-52
#36-----18
#42-15-6--
#5---3--26
#8-12-6--5
#-9-5-----
#''',
#    
#'''
#2-----57-
#---17-2-6
#---2----8
#536--2-87
#1--7-6--3
#74-3--692
#6----4---
#4-2-18---
#-15-----4
#''',
#    
#    
##hard
#'''
#2--4-6-7-
#--4--2---
#15-97----
#-3--6-4--
#7-1-4-9-3
#--8-9--1-
#----54-29
#---7--8--
#-2-6-9--1
#''',
#
##medium
#'''
#-67-2-3--
#--37-----
#92-1-3---
#4-2-35-6-
#3-------2
#-1-24-9-3
#---5-8-39
#-----92--
#--8-1-75-
#''',
#
###easy
#'''
#-61----9-
#43--95-6-
#9--1-2--3
#---4-1--9
#5-9---7-1
#6--2-9---
#3--9-8--6
#-8-73--42
#-9----31-
#''',
#
#'''
#--6-9---7
#84-73216-
#---1---42
#49----73-
#--3---2--
#-17----96
#93---4---
#-61329-78
#7---5-9--
#''',

]

## 将数据转换成三维数组的形式，以方便处理
def get_init_data(data):
    data = data.strip()
    data = data.split('\n')
    result = [[] for x in data]
    for i, x in enumerate(data):
        for y in x:
            if y=='-':result[i].append(['-'])
            else: result[i].append([y])
    
    return result

## 输出数据，方便查看和调试
def print_done_data(data):
    sys.stdout.write('='*80)
    sys.stdout.write('\n')
    for i, x in enumerate(data):
        for j, y in enumerate(x):
            s = '%s'%(''.join(y))
            
            # 如果没有填入数，则用-表示
            if s=='': s='-'
            sys.stdout.write('%6s'%s)
            
            # 每三列的地方，输出分隔符
            if j!=8 and j%3==2:
                sys.stdout.write(' |')
            else: sys.stdout.write('  ')
            
        sys.stdout.write('\n')
        # 每三行的地方，输出分隔符
        if i!=8 and i%3==2:
            sys.stdout.write('-'*80)
            sys.stdout.write('\n')
            
    sys.stdout.write('='*80)
    sys.stdout.write('\n')
    
    return

## 初始化阵，将各种可能的数字填入
def init_for_adjust(data):
    for x in data:
        for y in x:
            # 对于空白的地方，填入9个数字，并用-开头做标记
            if y[0]=='-':
                y.extend([str(n) for n in range(1,10)])
    return data

## 根据给定的行列值，得到所在的小九宫格起始位置
def get_block_ends(row, col):
    rleft = 6
    rright = 9
    cleft = 6
    cright = 9
    if row<3:
        rleft = 0
        rright = 3
    elif row<6:
        rleft = 3
        rright = 6
        
    
    if col<3:
        cleft = 0
        cright = 3
    elif col<6:
        cleft = 3
        cright = 6
        
    return (rleft, rright, cleft, cright)

## 删除不可能的值
def remove_impossible(data):
    for i,x in enumerate(data):
        for j,y in enumerate(x):
            # 对于确定的值，那么所有的行，列，小九宫格中将不可能再出现这个值
            if len(y)==1 and y[0]!='-':
                
                # remove_impossible row
                for z in x:
                    if z!=y:
                        try:z.remove(y[0])
                        except:pass
                
                #remove_impossible column
                for z in data:
                    if z[j]!=y:
                        try:z[j].remove(y[0])
                        except:pass
                        
                #remove_impossible block
                (rleft, rright, cleft, cright)=get_block_ends(i, j)
                for ri in range(rleft, rright):
                    for ci in range(cleft, cright):
                        if data[ri][ci]!=y:
                            try : data[ri][ci].remove(y[0])
                            except:pass
                
    return

## 只有一个可能值的格子，那这个格子一定是这个值
def remove_done(data):
    ret = True
    for x in data:
        for y in x:
            if len(y)==2 and y[0]=='-':
                y.remove('-')
                ret = False
    
    return ret

## 确定数独的状态，这里分为错误、未完成、ok三种状态
def sukudo_state(data):
    # 这里用列表来比较
    DONE = [x for x in '123456789']
    # test row
    for row in data:
        # 如果出现只有['-']的情况，那么是出错了
        try: 
            row.index(['-'])
            return 'error'
        except: pass
        
        t = []
        for x in row:
            t+=x
        t.sort()
        if t!=DONE:
            # 长度相同，但内容不同，那一定是错误
            if len(t)==len(DONE):
                return 'error'
            # 长度不同，这里认为是没有处理完
            return 'not finished'
    
    # test column
    for ci in range(9):
        t=[]
        for row in data:
            t+=row[ci]
        t.sort()
        if t!=DONE: 
            if len(t)==len(DONE):
                return 'error'
            return 'not finished'
    
    # test block
    for i in range(3):
        rleft = i*3
        rright = rleft+3
        for j in range(3):
            cleft = j*3
            cright = cleft+3
            t = []
            for ti in range(rleft, rright):
                for tj in range(cleft, cright):
                    t+=data[ti][tj]
            t.sort()
            if t!=DONE:
                if len(t)==len(DONE):
                    return 'error'
                return 'not finished'
    return 'ok'

## 一行中只有一个格子出现某个值，那么这个格子就只能是这个值
def intelligent_row(data):
    # intelligent row
    for x in data:
        t = []
        for y in x:
            if len(y)>1 and y[0]=='-':
                t.extend(y[1:])
        s = set(t)
        for item in s:
            if t.count(item)==1:
                for i, y in enumerate(x):
                    try: 
                        y.index(item)
                        x[i]=[item]
                        break
                    except:pass

## 一列中只有一个格子出现某个值，那么这个格子就只能是这个值
def intelligent_column(data):
    # intelligent column
    for ci in range(9):
        t = []
        for row in data:
            if len(row[ci])>1 and row[ci][0]=='-':
                t.extend(row[ci][1:])
        s = set(t)
        for item in s:
            if t.count(item)==1:
                for i, y in enumerate(data):
                    try: 
                        y[ci].index(item)
                        data[i][ci]=[item]
                        break
                    except:pass
            
## 一个小九宫格中只有一个格子出现某个值，那么这个格子就只能是这个值
def intelligent_block(data):
    # intelligent block
    for i in range(3):
        rleft = i*3
        rright = rleft+3
        for j in range(3):
            cleft = j*3
            cright = cleft+3
            t = []
            for ti in range(rleft, rright):
                for tj in range(cleft, cright):
                    if len(data[ti][tj])>1 and data[ti][tj][0]=='-':
                        t.extend(data[ti][tj][1:])
            s = set(t)
            for item in s:
                if t.count(item)==1:
                    for ti in range(rleft, rright):
                        for tj in range(cleft, cright):
                            try: 
                                data[ti][tj].index(item)
                                data[ti][tj]=[item]
                                break
                            except:pass
    
    return

## 简单地推断，直到结果不再发生变化
def easy_talent(data):
    save_data = []
    while cmp(save_data, data)!=0:
        remove_impossible(data)
        save_data = copy.deepcopy(data)
        
        intelligent_row(data)
        remove_done(data)
        remove_impossible(data)
#        sys.stdout.write('\n\nafter intelligent row\n')
#        print_done_data(data)
        
        intelligent_column(data)
        remove_done(data)
        remove_impossible(data)
#        sys.stdout.write('\n\nafter intelligent column\n')
#        print_done_data(data)
        
        intelligent_block(data)
        remove_done(data)
        remove_impossible(data)
#        sys.stdout.write('\n\nafter intelligent block\n')
#        print_done_data(data)
        
        remove_done(data)
        remove_impossible(data)
        sys.stdout.write('\n\nafter remove done data\n')
        print_done_data(data)
    return

#找到最少可能的格子，用于假设推算
def get_least_cell(data):
    (ri, rj) = (10,10)
    t = False
    for i in range(9):
        for j in range(9):
            if data[i][j][0]=='-':
                ri, rj = i, j
                t = True
                break
        if t: break
    for i in range(ri, 9):
        for j in range(rj, 9):
            if len(data[i][j])<len(data[ri][rj]) and data[i][j][0]=='-':
                (ri,rj)=(i,j)
    return (ri, rj)

## 假设推断，对格子中的各个值进行假设推断
def suppose_talent(data):
    state = sukudo_state(data)
    if state=='ok': 
        # 完成后的数独，则输出
        print '* done data:'
        print_done_data(data)
        return
    elif state=='error':
        # 数独不正确，直接返回
        return
    
    # 数独没有完成时，则会来到这里进行处理
    i , j = get_least_cell(data)
    t = [x for x in data[i][j][1:]]
    for x in t:
        # 推断前，先保存当前状态
        save_data = copy.deepcopy(data)
        data[i][j] = [x]
        
        # 作了假设后，继续进行简单的推断
        easy_talent(data)
        state =sukudo_state(data)
        
        # 如果完成了就输出，如果还未完成，则继续假设
        if state =='ok': 
            print '* done data:'
            print_done_data(data)
            return
        elif state=='not finished': 
            suppose_talent(data)
            return
        # 推断的不正确时，会来到这里
        # 恢复状态
        data = save_data
    return

import copy

if __name__=='__main__':

    for data in data_list:
        data = get_init_data(data)
        
        print '*original data:'
        print_done_data(data)
        
        init_for_adjust(data)
        
        easy_talent(data)
        suppose_talent(data)

    pass

转载于:https://my.oschina.net/KavenFan/blog/83170

chouganghan1242
关注
如何用python计算数独_python实现数独算法实例
weixin_33865450的博客
02-05 374
本文实例讲述了python实现数独算法的方法。分享给大家供大家参考。具体如下： # -*- coding: utf-8 -*-'''Created on 2012-10-5@author: Administrator'''from collections import defaultdictimport itertoolsa = [[ 0, 7, 0, 0, 0, 0, 0, 0, 0], #0[...
python 实现计算数独
weixin_30940783的博客
06-13 166
输入文件格式： 008309100900060004007504800036000540001000600042000970005907300600010008004608200 输出结果： yuan********************0 0 8 3 0 9 1 0 0 9 0 0 0 6 0 0 0 4 0 0 7 5 0 4 8 0 0 0 3 6 0 0 0 5 4 0...
用python解数独_python解数独
weixin_35055546的博客
02-05 925
python 解数独一、数独规则：\qquad数独共有九九八十一个小方格，要求每一行、每一列的小方格都包含数字1-9,且不能重复；将这个方格平均分成9个3 ∗*∗ 3的方格，每个方格的数字也必须包含1-9，且不能重复。二、解题思路\qquad 1、获取每一个空缺方格的坐标；\qquad 2、遍历每一个空缺方格的坐标进行取可能的值，遍历从1-9进行取值。\qquad(1)若满足数字不包含在空缺坐标的...
python实现数独算法实例
09-21
### Python 实现数独算法详解 #### 一、引言 数独是一种流行的逻辑填数字游戏，玩家需要根据已有的数字，在一个9×9的网格中填入数字1至9，使得每一行、每一列以及每一个3×3的小宫格内都不出现重复的数字。本篇...
Python数独游戏源代码
02-11
Python数独游戏是一种基于Python编程语言开发的桌面应用程序，它利用了Python的灵活性和易读性，为用户提供了一个交互式的数独游戏体验。这个压缩包包含的文件是"main.py"和"build.py"，它们构成了游戏的核心部分。 ...
python实现数独游戏 java简单实现数独游戏
09-20
本篇文章将探讨如何使用Python和Java这两种编程语言实现数独游戏的生成与打印功能。 首先，我们来看Python实现。在Python版本中，`make_board`函数用于生成数独盘面。它首先创建一个包含1到9的数字列表，然后通过`...
Python解数独算法
cmh0221的博客
04-13 648
array = [["5", "3", ".", ".", "7", ".", ".", ".", "."], ["6", ".", ".", "1", "9", "5", ".", ".", "."], [".", "9", "8", ".", ".", ".", ".", "6", "."], ["8", ".", ".", ".", "6", ".", ".", ".", "3"], ["4", ".", ".", "8", ".
数独计算辅助工具
06-06
一款数独类游戏的辅助软件，可以帮助你快速求解数独问题，并给出了辅助界面，帮助完成
数独游戏详解（附有Python详细代码）
Weirdo的博客
05-28 2419
数独游戏是一种源自18世纪末欧洲的逻辑谜题游戏,在20世纪初在美国获得了广泛的流行。它的规则简单明了,但要解决一个困难的数独游戏实际上是一个NP完全的问题,需要采用各种算法和启发式方法来有效地解决。因此,数独游戏不仅是一种有趣的益智游戏,也是一个非常有价值的数学问题,可以用来研究人工智能算法和组合优化技术。
数独小游戏——Python实现
Vaeeeee的博客
07-19 7290
使用python简单实现一下数独小游戏，并且使用tkinter进行界面展示。
利用python解决简单数独
jingzhiyang的博客
08-23 3132
本来打算利用pyautogui实现完全的自动化的。但是考虑到不同的网页的数独呈现方式的差异可能会使得程序的局限性更大。于是采用了一种麻烦一点，但可以接受的方式进行数据输入。但是之后的思考模式代码化就不是很容易了。不过笔者并不算十分忠实的数独玩家，但数独是一种规则和形式都十分简单的游戏。以上代码还有诸多不足，有很多看上去多余的部分是留着给更复杂的判断方式的。所以最终的结果大概算是一个半成品，但已经能解决比较基本的数独。用0来代表未知的数字，其他的数字则表示已知数字。于是萌生了用python来解决数独的想法。
Python 数独求解
L_Jane_H的博客
07-03 3017
数独求解
Python学习案例2——数独解题及出题程序
07-20 2922
第二个求解案例，我想到了数独。曾经有一段时间对数独求解非常感兴趣，在学习C++语言时也编写了数独求解程序。本次Python学习，要求比之前高一点，把出题程序也一起编写了吧。 1、数独简介 数独 （英语：Sudoku）是一种逻辑性的数字填充游戏，玩家须以数字填进每一格，而每行、每列和每个宫（即3x3的大格）有1至9所有数字。游戏设计者会提供一部分的数字，使谜题只有一个答案。答案满足同一个数字不可能在同一行、列或宫中出现多于一次。 2、算法 2.1 数独解题算法 最简单直接的算法就是：从第一个空格开始
使用Python进行数独求解（一）
sgzqc的专栏
02-17 6876
1. 引言 本文为介绍流行的数独游戏的系列文章中的第一篇。更具体地说，我们如何构建一个脚本来解决数独难题，本文的重点在于介绍用于构建数独求解器的回溯算法。 数独这个名字的由来来自日语短语suuji wa dokushin ni kagiru，意思是“数字必须保持单一”。数独游戏的流行也源于其规则的简单性：数独游戏要求在 9 x 9 空间的网格上进行数字填写。在行和列中有 9 个“正方形”的格子block(由 3 x 3 个子单元格cell组成)。每一行、每一列、每一个block都需要填写数字 1-9，行、
数独解法的Python实现
往旁边坐坐，压到我隐形的翅膀了
12-15 3561
import itertoolssudoku = [[0,0,0,4,0,8,0,0,0], [5,2,0,9,0,6,0,4,1], [7,8,0,2,0,3,0,5,6], [0,9,0,0,0,0,0,2,0], [0,0,0,0,0,0,0,0,0], [0,5,0,0,0,0,0,9,0],
Python数独算法
weixin_45551676的博客
05-05 2471
最近突然对数独感兴趣，玩了好几天。慢慢摸索出了一些解题规律，就想着能不能用代码自动化实现。趁五一放假试着写了点代码，效果还行，至少不比网上一些教程里慢太多，因此就放到这里跟大家分享一下。 由于本人也是Python新手，很多语句可能不够简洁，还望见谅。 完整代码可见github链接：https://github.com/linking9230/sudoku.git 一、数独输入 我准备了两套数独题目...
pandas中数据子集的获取
最新发布
weixin_43597208的博客
10-14 498
通常，在pandas模块中实现数据框子集的获取可以使用iloc、loc和ix三种方法，这三种方法既可以对数据行进行筛选，也可以实现变量的筛选，它们的语法可以表示成[rows_select,cols_select]。iloc只能通过行号和列号进行数据的筛选，可以将iloc中的i理解为’integer’，即只能向[rows_select,cols_select]指定整数列表该索引方式与数组的索引方式类似，都是从0开始，可以间隔取号，对于切片仍然无法取到上限。
Python制作数独游戏教程
资源摘要信息:"生成数独游戏的Python程序" 生成数独游戏的Python程序是面向程序员和数独爱好者的实用工具，可用于创建和解决数独谜题。数独是一种逻辑填数游戏，通常在9x9的网格内进行，分为9个3x3的小区域，玩家需...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值