下面是1一一9九宫格数独口诀游戏,求解

无限数独|无限数独游戏下载V2.4.1 绿色中文版_西西游戏下载
西西软件园多重安全检测下载网站、值得信赖的软件下载站!
相关软件 186KB/中文/ 1KB/中文/ 2.8M/中文/ 3.0M/繁体/ 906KB/英文/ 608KB/中文/ 2.3M/英文/ 2.0M/中文/ 2.8M/中文/ 349KB/中文/顶好评:50%踩坏评:50请简要描述您遇到的错误,我们将尽快予以修正。轮坛转帖HTML方式轮坛转帖UBB方式
数独是一个智力小游戏。一个9*9的棋盘,共有9行9列以及9个互不相交的3*3九宫格。里面某些格子开始已经填上了1-9中的一些数字。要求玩家在余下的空格中填上1-9中数字,使得每行,每列和每个3*3九宫格中都正好包含1-9数字各一个。保证结果的存在和唯一性。无限数独游戏功能: i)&&随机产生任意多的游戏(理论上可以产生2^96=50336个不同的游戏)ii)&游戏分成四个不同级别(入门级,高级,专家级,骨灰级) iii)&通过模拟人工解数独问题提供人性化的提示,几乎所有游戏都完全可以仅用提示解决iv)提供尝试功能(使用Shift键加数字键或鼠标左键)v)可以用户自定义游戏,用户可以直接输入或者通过剪切板复制游戏vi)可以将计算机模拟人工求解过程复制到剪切板(Ctrl+U键)vii)语音提示功能(M键切换语音功能)viii)历史记录图形化回放功能ix)语音命令功能游戏说明:玩游戏过程:如上图,在游戏中还没有填充的格子中,在候选数显示模式,计算机会自动显示所有的候选数。其中黑色大数字是游戏事先设置好的数字,蓝色大数字是玩家填充的数字,黑色小数字是每个格子的候选数。但是在非候选数模式,计算机不会显示候选数。用户可以使用鼠标或键盘玩游戏。用鼠标左键点击一个候选数(仅用于候选数显示模式)或鼠标在格子上时按数字键选择一个数1-9。用鼠标右键或同时按住Ctrl和数字键来减少或添加候选数(仅用于候选数显示模式)。按H或Ctrl+H获得提示。显示部分候选数功能:仅提供键盘操作。按住Ctrl+Shift+数字键1-9分别只显示候选数1到9。Ctrl+Shift+0显示所有候选数。而在显示部分候选数时,也可以通过左右键改变当前显示的候选数。游戏还提供无限制步数的取消和重做功能,任何时候可以通过菜单项&编辑/取消”或热键Ctrl+Z取消上一步操作。对于取消后的步骤可以通过Ctrl+Y键重做。 批量取消功能:通过用鼠标右键点击一个用户已经设置好的数据,这将取消这个格子里面的数据,并且所有在设置这个数字后面的步骤全部被取消。同样,用右键点击一个已经被加灰(推理删除)的候选数(仅用于候选数显示模式),将取消将这个候选数隐含的步骤,同时它后面的所有步骤也全部取消。在批量取消后,同样可以通过选择菜单项“重做”来重新使用这些被取消的步骤, 如果因为错误操作(比如不小心用鼠标右键点中一个格子),可以通过按Shift+Y来重做所有被取消的步骤。游戏技巧:i)唯一数法如果我们发现某个格子中只有一个可用候选数,那么这个格子必然是这个数字,这就是唯一数法如下面例子,H5格子中只有唯一候选数3如果没有使用候选数模式,那么得到提示信息会如下图ii)隐含唯一数法如果我们发现某一行某一列或某个九宫有一个候选数只出现在一个格子里面,那么这个格子必然是这个数字,这就是隐含唯一数法,如下面例子,第3列候选数4只出现在格子I3中. 本软件还提供了一种显示单一候选数的模式,在单一候选数模式,我们可以更加容易找到隐含唯一数。比如在这里,我们按Ctrl+Shift+4,那么软件将会只显示候选数4,在这种模式下,就可以非常容易看出I3中的4是隐含唯一数。如果没有使用候选数模式,得到提示如下:而对于隐含唯一候选数法(还有区间删减法和各种矩形法)我们还可以使用单一候选数模式,比如对于这个例子我们可以通过按Ctrl+Shift+4键只显示候选数4,得到如下一个图,根据下图,很显然I3中4是隐含唯一数iii)数对法如果我们发现某一行某一列或某个九宫有两个格子只使用了两个候选数,那么这两个格子必然正好是这两个数字,那么在这个单元(行,列,或九宫)中,其它格子不会出现这两个候选数,这就是数对法,如下面例子,第一列中B1和G1的候选数都是7,8;那么D1,H1中的候选数7,8可以删除。iv)三链数法如果我们发现某一行某一列或某个九宫有三个格子只使用了三个候选数,那么这三个格子必然正好是这三个数字,那么在这个单元(行,列,或九宫)中,其它格子不会出现这三个候选数,这就是三链数法,如下面例子,最下面中间的九宫中格子H4,H5,I5三个格子都只使用候选数2,8,6;所以G4,G6,I6中出现的8,6都可以删除v)四链数法如果我们发现某一行某一列或某个九宫有四个格子只使用了四个候选数,那么这四个格子必然正好是这四个数字,那么在这个单元(行,列,或九宫)中,其它格子不会出现这四个候选数,这就是四链数法;如下面例子中上面中间的九宫中四个格子A5,B5,C4,C5都只使用了数字1,2,3,4;所以另外4个格子A4,A6,B4,C6中出现的数字1,2,3,4可以删除
数独游戏是一款考验数学能力与智力的一个益智类的游戏,它是一个源自于18世纪的瑞士末的一款游戏,十分的考验动脑能力。数独发源于瑞士,后来在美国、日本传扬开来,需要玩家在9宫格中填上数字,并且每行每列的9个数
英文 / 906KB数独(Sudoku)「数独」的意思是「
英文 / 2.3M数独达人 Sudoku Master是一款数
中文 / 8.0M数独是一种推理解密类的游戏,它
中文 / 5.1M数独tv版可以让用户在电视机前玩
中文 / 33.1MJogatina数独,一款传统数独游戏
中文 / 3.4M心常乐数独小游戏是简单的数独小
无限数独游戏 V2.4.1 绿色中文版
下载帮助西西破解版软件均来自互联网, 如有侵犯您的版权, 请与我们联系。扫二维码下载作业帮
拍照搜题,秒出答案,一键查看所有搜题记录
下载作业帮安装包
扫二维码下载作业帮
拍照搜题,秒出答案,一键查看所有搜题记录
数独游戏答案 要求 大方格每列都有1——9 大方格每行都有1——9 每个中等方格都有1—9
作业帮用户
扫二维码下载作业帮
拍照搜题,秒出答案,一键查看所有搜题记录
终于弄完了
感觉好的话
为您推荐:
其他类似问题
扫描下载二维码温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!&&|&&
对于本博客内所有原创文章和代码的引用必须标明“来源:http://simplesource.blog.163.com/”。如需应用于商业目的必须经本人同意,本人对所有原创文章和代码保留一切权利。
PS:需要部分程序源代码的请留下邮箱地址
LOFTER精选
网易考拉推荐
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
阅读(16567)|
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
历史上的今天
loftPermalink:'',
id:'fks_080',
blogTitle:'数独游戏求解程序(附源代码)',
blogAbstract:'&\r\n  数独游戏规则\r\n  是一种源自18世纪末瑞士的数学智力拼图游戏。拼图是九宫格(即3格宽×3格高)的正方形状,每一格又细分为一个九宫格。在每一个小九宫格中,分别填上1至9的数字,让整个大九宫格每一列、每一行的数字都不重复。 \r\n  数独的玩法逻辑简单,数字排列方式千变万化。不少教育者认为数独是锻炼脑筋的好方法。\r\n  计算机算法简介\r\n  本文所讨论的算法是一种通用算法,虽然不能说是最快的算法,但却可以求解所有的数独游戏。\r\n  算法准备:\r\n  1、一个可能性:表示某个格子可能填写的数字。\r\n',
blogTag:'',
blogUrl:'blog/static/',
isPublished:1,
istop:false,
modifyTime:9,
publishTime:3,
permalink:'blog/static/',
commentCount:35,
mainCommentCount:30,
recommendCount:0,
bsrk:-100,
publisherId:0,
recomBlogHome:false,
currentRecomBlog:false,
attachmentsFileIds:[],
groupInfo:{},
friendstatus:'none',
followstatus:'unFollow',
pubSucc:'',
visitorProvince:'',
visitorCity:'',
visitorNewUser:false,
postAddInfo:{},
mset:'000',
remindgoodnightblog:false,
isBlackVisitor:false,
isShowYodaoAd:false,
hostIntro:'对于本博客内所有原创文章和代码的引用必须标明“来源:http://simplesource.blog.163.com/”。如需应用于商业目的必须经本人同意,本人对所有原创文章和代码保留一切权利。\nPS:需要部分程序源代码的请留下邮箱地址',
hmcon:'1',
selfRecomBlogCount:'0',
lofter_single:''
{list a as x}
{if x.moveFrom=='wap'}
{elseif x.moveFrom=='iphone'}
{elseif x.moveFrom=='android'}
{elseif x.moveFrom=='mobile'}
${a.selfIntro|escape}{if great260}${suplement}{/if}
{list a as x}
推荐过这篇日志的人:
{list a as x}
{if !!b&&b.length>0}
他们还推荐了:
{list b as y}
转载记录:
{list d as x}
{list a as x}
{list a as x}
{list a as x}
{list a as x}
{if x_index>4}{break}{/if}
${fn2(x.publishTime,'yyyy-MM-dd HH:mm:ss')}
{list a as x}
{if !!(blogDetail.preBlogPermalink)}
{if !!(blogDetail.nextBlogPermalink)}
{list a as x}
{if defined('newslist')&&newslist.length>0}
{list newslist as x}
{if x_index>7}{break}{/if}
{list a as x}
{var first_option =}
{list x.voteDetailList as voteToOption}
{if voteToOption==1}
{if first_option==false},{/if}&&“${b[voteToOption_index]}”&&
{if (x.role!="-1") },“我是${c[x.role]}”&&{/if}
&&&&&&&&${fn1(x.voteTime)}
{if x.userName==''}{/if}
网易公司版权所有&&
{list x.l as y}
{if defined('wl')}
{list wl as x}{/list}芬兰一位数学家号称设计出全球最难的“数独游戏”,并刊登在报纸上,让大家去挑战。这位数学家说,他所设计的数独游戏难度等级是十一,可以说是所有数独游戏中,难度最高的等级。
编程求解的方法有两种
穷举法:穷举法算法简单,但运行时所花费的时间量大,这里主要讨论回溯法。
回溯法:按照深度搜索的方式进行。即在第一层选定一个满足约束条件的解,然后以该可能解为出发点,搜索第二层的一个可能解(试探)。如果搜索到第二层的一个可能解,则继续搜索第三层的一个可能解。依次类推,直到所有层的可能解都被找到,则得到了该问题的一个完整解。如果第二层所有的可能解都不满足约束条件,则返回第一层,放弃原有的可能解,使用第一层的下一个可能解(回溯)。以此类推,寻找第二层的一个可能解。
数独问题的约束条件为:
l)数值范围仅限于l一9。
2)行中不允许重复数字。
3)列中不允许重复数字。
4)小九宫内不允许重复数字。
此处仅仅考虑最简单的场景,并没有在性能上做优化。关于算法性能,老外有一篇文章讲解的很棒 "Solving Every Sudoku Puzzle"。
对应python代码如下
class Suduko(object):
def __init__(self, s):
self.s = s
def check_all(self, i, j, value):
#检测s[i][j]=value时,是否满足数独约束
return self.check_row(i, j, value) and self.check_column(i, j, value)\
and self.check_small_sudoku(i, j, value)
def check_row(self, i, j, value):
#检测s[i][j]=value是否满足 行中不允许重复数字
return value not in self.s[i]
def check_column(self, i, j, value):
#检测s[i][j]=value是否满足 列中不允许重复数字
column = [self.s[v][j] for v in range(9)] return value not in column
def check_small_sudoku(self, i, j, value):
#检测s[i][j]=value是否满足 小九宫格不允许重复数字
small_sudoku = [self.s[m][n] for m in range(i/3*3,(i/3+1)*3)\ for n in range(j/3*3,(j/3+1)*3)]
return value not in small_sudoku
def recursion_search(self):
#回溯求解,如果i,j都大于等于8,表示求解OK
i,j = self.start_point()
if i &=8 and j &=8 and self.s[8][8]:
return True
for value in range(1,10):
if self.check_all(i, j, value):
self.s[i][j] = value #如果s[i][j]满足约束,则令s[i][j]=value
if not self.recursion_search():
self.s[i][j] = 0 #如果后面的递归搜索不满足要求,令s[i][j] = 0
return True
return False #如果该点遍历1-9都不符合要求,则表示上游选值不当,回溯
def start_point(self)“
for i in range(9):
for j in range(9):
if not self.s[i][j]:
return i,j
return i,j
if '__main__' == __name__:
s = [[8,0,0,0,0,0,0,0,0],
[0,0,3,6,0,0,0,0,0],
[0,7,0,0,9,0,2,0,0],
[0,5,0,0,0,7,0,0,0],
[0,0,0,0,4,5,7,0,0],
[0,0,0,1,0,0,0,3,0],
[0,0,1,0,0,0,0,6,8],
[0,0,8,5,0,0,0,1,0],
[0,9,0,0,0,0,4,0,0]]
S = Suduko(s)
S.recursion_search()
for i in range(9):
print S.s[i]
求解答案如下
[8, 1, 2, 7, 5, 3, 6, 4, 9]
[9, 4, 3, 6, 8, 2, 1, 7, 5]
[6, 7, 5, 4, 9, 1, 2, 8, 3]
[1, 5, 4, 2, 3, 7, 8, 9, 6]
[3, 6, 9, 8, 4, 5, 7, 2, 1]
[2, 8, 7, 1, 6, 9, 5, 3, 4]
[5, 2, 1, 9, 7, 4, 3, 6, 8]
[4, 3, 8, 5, 2, 6, 9, 1, 7]
[7, 9, 6, 3, 1, 8, 4, 5, 2]
没有更多推荐了,python学习笔记-利用回溯法求解数独问题
数独游戏最近很流行,报纸上经常会有一些题目。有空的时候我也会去做做,但是实在太耗脑子,所以干脆试着写个程序来解数独问题。
我平时做数独题目的时候,基本思路是这样的:先对每个格子,列出每个格子中当前可以放的数字(候选数)。然后,找出其中候选数最少的那个格子,在该格子中
依次放入每个候选数,然后继续判断其他格子。在题目比较难的时候,这样做真的很费脑子,但是,让计算机来做这个,应该是一件轻而易举的事情。所以,我们这
个程序也将采用这个算法:
1. 建立堆栈,将题目作为初始值,压入堆栈
2. 若堆栈不为空,则不断循环:
&&&&&&&&&&&&&&&&&&&&
a) 从堆栈中取出一个当前解,遍历所有格子
&&&&&&&&&&&&&&&&&&&&&&&&&&&
i.若当前格子已有数字,则跳过
&&&&&&&&&&&&&&&&&&&&&&&&&&&
ii.若当前格子暂未放置数字,则计算当前格可以放置的候选数列表
&&&&&&&&&&&&&&&&&&&&&&&&&&&
iii.若当前格子候选数个数最少,则保存当前位置及候选数信息
&&&&&&&&&&&&&&&&&&&&&&&&&&&
iv.若某一格子候选数为空,则直接跳出遍历过程,重新从堆栈中取新的临时解进行计算
&&&&&&&&&&&&&&&&&&&&&&&&&&&
v. 若所有格子都已经存在数字,则表示该解即为最终解,直接跳出循环,返回该解
&&&&&&&&&&&&&&&&&&&&
b) 遍历完成后,已获取最少候选数的格子位置及候选数。对该格子,依次放入候选数,并作为新的临时解放入堆栈
下面举个简单示例 :
第一步,可以判断,在右下角这个9宫格中有四个数字,因此该区域最多候选个数只有5个,列出候选数后,发现第8行第7列只有两个,因此取该格进行下一步计算
先取候选数9,发现上一个格子中候选数只有2个(3,5),取该格继续计算
以此类推,不断重复这个过程,即可得到结果:
下面是python的源代码:
#!/usr/bin/python
# -*- coding:utf-8 -*-
import string
import copy
import time
#从文件中读取数独问题,每题之间用";"分隔,各数字之间用空格分隔
def read_problem():
inputFile=file('Sudoku_input.txt','r')
rtnList=[]
lProblem=[]
line=inputFile.readline()
line=line.strip()
&&& if len(line)
line==';':
rtnList.append(copy.deepcopy(lProblem))
lProblem=[]
rowList=line.split(' ')
numberList=[]
&&& for number
in rowList:
number=int(number)
numberList.append(number)
lProblem.append(numberList)
&&& return
#数独求解程序
# lProblem:数独问题,由一个二维数组表示
# logFile:
日志文件,将求解结果输出到这个文件中&&&
def sudoku_solver(lProblem,logFile):
lSolverStack=[lProblem]
若堆栈不为空,则循环
len(lSolverStack)&0:
lCurrSolution=lSolverStack.pop()
count=count+1
logFile.write("%d" % count + '\n')
&&& for row in
lCurrSolution:
outLine=''
&&& for number
outLine=outLine + "%d" % number +' '
logFile.write(outLine+'\n')
logFile.write("---------------------------\n")
isResult=True
#用于存放当前最少候选数列表
lMinAvailableNumber=range(1,10)
#当前最少候选数所在位置
lMinAvailableNumberX=0
lMinAvailableNumberY=0
&&& for idx in
range(81):
lCurrSolution[i][j]==0:
isResult=False
#计算当前位置可以放置的数字列表
lCurrAvailableNumber=range(1,10)
#如果同一行中存在相同元素,则排除
&&& for x in
lCurrAvailableNumber.count(lCurrSolution[i][x])&0:
lCurrAvailableNumber.remove(lCurrSolution[i][x])
#如果同一列中存在相同元素,则排除
&&& for y in
lCurrAvailableNumber.count(lCurrSolution[y][j])&0:
lCurrAvailableNumber.remove(lCurrSolution[y][j])
#如果当前位置所在的小九宫格中存在相同元素,则排除
&&& for x in
range(i/3*3,i/3*3+3):
&&& for y in
range(j/3*3,j/3*3+3):
lCurrAvailableNumber.count(lCurrSolution[x][y])&0:
lCurrAvailableNumber.remove(lCurrSolution[x][y])
#如果当前单元格中可选数字个数最少,则保留&&&
len(lCurrAvailableNumber)&len(lMinAvailableNumber):
lMinAvailableNumber=copy.deepcopy(lCurrAvailableNumber)
lMinAvailableNumberX=i
lMinAvailableNumberY=j
len(lMinAvailableNumber)==0:
#若当前位置存在可选数字,则将当前位置的所有可选数字,依次作为临时解,并存入堆栈
len(lMinAvailableNumber)&0:
&&& for number
in lMinAvailableNumber:
lNewSolution=copy.deepcopy(lCurrSolution)
lNewSolution[lMinAvailableNumberX][lMinAvailableNumberY]=number
lSolverStack.append(lNewSolution)&&&
&&& return
lCurrSolution
&&& return
if __name__=='__main__':
resultFile=open("Sudoku_output.txt",'w')
lProblemList=read_problem()
&&& print "Start
solving.."
&&& for lProblem
in lProblemList:
count=count+1
resultFile.write("Solving Problem:"+"%d" % count + ":" +
logFile=open("Problem_"+"%d" % count+".log","w")
startTime=time.time()
lResult=sudoku_solver(lProblem,logFile)
logFile.close()
endTime=time.time()
"& Problem " + "%d" % count + ": finished! Time
consuming: " + "%.4f" % (endTime-startTime) + " Seconds"
len(lResult)==0:
resultFile.write("No Answer...\n")
&&& for row in
outLine=''
&&& for number
outLine=outLine + "%d" % number +' '
resultFile.write(outLine+"\n")
resultFile.write("--------------------------------\n")
resultFile.close()
输入文件:
8 0 0 0 0 0 0 0 0
0 0 3 6 0 0 0 0 0
0 7 0 0 9 0 2 0 0
0 5 0 0 0 7 0 0 0
0 0 0 0 4 5 7 0 0
0 0 0 1 0 0 0 3 0
0 0 1 0 0 0 0 6 8
0 0 8 5 0 0 0 1 0
0 9 0 0 0 0 4 0 0
0 9 0 6 0 0 7 0 1
2 0 0 0 0 3 0 8 4
7 0 3 0 0 0 0 0 0
0 3 0 0 6 1 0 0 0
6 0 0 0 0 0 0 0 8
0 0 0 9 4 0 0 7 0
0 0 0 0 0 0 5 0 2
1 5 0 3 0 0 0 0 9
9 0 6 0 0 2 0 1 0
输出结果:
Solving Problem:1:
8 1 2 7 5 3 6 4 9
9 4 3 6 8 2 1 7 5
6 7 5 4 9 1 2 8 3
1 5 4 2 3 7 8 9 6
3 6 9 8 4 5 7 2 1
2 8 7 1 6 9 5 3 4
5 2 1 9 7 4 3 6 8
4 3 8 5 2 6 9 1 7
7 9 6 3 1 8 4 5 2
--------------------------------
Solving Problem:2:
4 9 8 6 2 5 7 3 1
2 6 5 7 1 3 9 8 4
7 1 3 8 9 4 2 5 6
8 3 7 2 6 1 4 9 5
6 4 9 5 3 7 1 2 8
5 2 1 9 4 8 6 7 3
3 7 4 1 8 9 5 6 2
1 5 2 3 7 6 8 4 9
9 8 6 4 5 2 3 1 7
--------------------------------
求解第一个问题,迭代了5573次,用了 4.5920秒
第二个问题,迭代了54次,用了 0.0310秒
总结一下,一开始我有点偷懒,在计算过程中,没有每次选取最少候选数的那个格子去计算,导致计算量急剧增大,第一个题目要跑很久,看来算法还是很重要的。下一步想尝试去把程序增强一下,让程序能够自己出数独的题目。
已投稿到:
以上网友发言只代表其个人观点,不代表新浪网的观点或立场。

我要回帖

更多关于 经典数独游戏 的文章

 

随机推荐