实施非猜测数独解算器

实施最短的数独求解器。

数独拼图：

 | 1 2 3 | 4 5 6 | 7 8 9
-+-----------------------
A|   3   |     1 |
B|     6 |       |   5
C| 5     |       | 9 8 3
-+-----------------------
D|   8   |     6 | 3   2
E|       |   5   |
F| 9   3 | 8     |   6
-+-----------------------
G| 7 1 4 |       |     9
H|   2   |       | 8
I|       | 4     |   3

回答：

 | 1 2 3 | 4 5 6 | 7 8 9
-+-----------------------
A| 8 3 2 | 5 9 1 | 6 7 4
B| 4 9 6 | 3 8 7 | 2 5 1
C| 5 7 1 | 2 6 4 | 9 8 3
-+-----------------------
D| 1 8 5 | 7 4 6 | 3 9 2
E| 2 6 7 | 9 5 3 | 4 1 8
F| 9 4 3 | 8 1 2 | 7 6 5
-+-----------------------
G| 7 1 4 | 6 3 8 | 5 2 9
H| 3 2 9 | 1 7 5 | 8 4 6
I| 6 5 8 | 4 2 9 | 1 3 7

规则：

假设所有迷宫只能通过逻辑解决。
所有输入将为81个字符长。缺少的字符将为0。
将解决方案输出为单个字符串。
您可以根据需要在内部存储“网格”。
该解决方案必须使用非猜测的解决方案。（请参阅数独求解器）

I / O示例：

>sudoku.py "030001000006000050500000983080006302000050000903800060714000009020000800000400030"
832591674496387251571264983185746392267953418943812765714638529329175846658429137

— Snmcdonald
source

您确实应该添加一个时间限制。

— JPvdMerwe，2011年

@JPvdMerwe：好点，但是时间限制很难标准化。

— snmcdonald

@gnibbler：之前可能已经做过（但在codegolf.se上没有）。我认为解决问题以及为社区增加价值仍然会很有趣，特别是如果人们诚实地做下去的话。

— snmcdonald

我喜欢这一个。我一直在犹豫不决尝试实际的高尔夫解决方案，并且我一直在考虑编写Sudoku求解器（这似乎很有趣）。我认为这是像我这样从来没有打过高尔夫球的人可以作为起点的东西。一旦拿出一个，我可能会打高尔夫球。

— 安迪（Andy）

“只能通过逻辑解决”的问题非常模糊。您的意思是，也许仅使用了以下基本步骤：a）在单元格中写入其值不在其行，列和块中的值b）标识只能在其行，列中某个位置出现的数字，或将其写入其中？

— xnor 2014年

Answers:

RUBY（~~449436~~字符）

I=*(0..8)
b=$*[0].split('').map{|v|v<'1'?I.map{|d|d+1}:[v.to_i]};f=b.map{|c|!c[1]}
[[z=I.map{|v|v%3+v/3*9},z.map{|v|v*3}],[x=I.map{|v|v*9},I],[I,x]
].map{|s,t|t.map{|i|d=[a=0]*10;s.map{|j|c=b[i+j];c.map{|v|d[v]+=1if !f[i+j]}
v,r=*c;s.map{|k|b[i+k].delete(v)if j!=k}if !r 
s[(a+=1)..8].map{|k|s.map{|l|b[i+l]-=c if l!=k&&l!=j}if c.size==2&&c==b[i+k]}}
v=d.index 1;f[i+k=s.find{|j|b[i+j].index v}]=b[i+k]=[v]if v}}while f.index(!1)
p b*''

例：

C:\golf>soduku2.rb 030001000006000050500000983080006302000050000903800060714000009020000800000400030
"832591674496387251571264983185746392267953418943812765714638529329175846658429137"

快速说明：
Board b是由81个数组组成的数组，其中包含每个单元格的所有可能值。第三行的数组为每个组（框，行，列）保存[offset，start_index]。在遍历组时执行三个任务。

大小为1的任何单元格的值都将从该组的其余部分中删除。
如果任何一对单元格包含相同的2个值，则将从其余组中删除这些值。
每个值的计数存储在d-如果一个值只有1个实例，我们将包含单元格设置为该值，并将该单元格标记为固定f

重复直到所有单元格都固定。

— 贝壳
source

您可以省略中的括号I=*(0..8)，将节省2个字符。

— Dogbert

我从sudokusolver.rb:8: unterminated string meets end of file开始就知道ruby1.8 sudokusolver.rb 030...。我究竟做错了什么？

— 用户未知，

看起来在最后一行还有一个额外的'。不知道那是怎么到达的...

— AShelly 2011年

Prolog-493个字符

:-use_module(library(clpfd)).
a(X):-all_distinct(X).
b([],[],[]).
b([A,B,C|X],[D,E,F|Y],[G,H,I|Z]):-a([A,B,C,D,E,F,G,H,I]),b(X,Y,Z).
c([A,B,C,D,E,F,G,H,I|X])-->[[A,B,C,D,E,F,G,H,I]],c(X).
c([])-->[].
l(X,Y):-length(X,Y).
m(X,Y):-maplist(X,Y).
n(L,M):-l(M,L).
o(48,_).
o(I,O):-O is I-48.
:-l(L,81),see(user),m(get,L),seen,maplist(o,L,M),phrase(c(M),R),l(R,9),m(n(9),R),append(R,V),V ins 1..9,m(a,R),transpose(R,X),m(a,X),R=[A,B,C,D,E,F,G,H,I],b(A,B,C),b(D,E,F),b(G,H,I),flatten(R,O),m(write,O).

输出：

输入： 000000000000003085001020000000507000004000100090000000500000073002010000000040009 输出： 987654321246173985351928746128537694634892157795461832519286473472319568863745219

输入： 030001000006000050500000983080006302000050000903800060714000009020000800000400030 输出： 832591674496387251571264983185746392267953418943812765714638529329175846658429137

— MT0
source