blocks|key|3244419|text|您需要检查数独的所有约束：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3244420|3244421|检查每行的总和|unordered-list-item|3244422|检查每列的总和|3244423|检查每个框的总和|3244424|检查每行的重复数字|3244425|检查每列的重复数字|3244426|检查每个框的重复数字|3244427|3244428|总共有6张支票..使用暴力手段。|3244429|如果您知道电路板的大小(即3x3或9x9)，则可以使用某种数学优化|3244430|编辑：对sum约束的解释:首先检查sum+(如果sum不是45，则停止)比检查重复要快得多(也更简单)。它提供了一种丢弃错误解决方案的简单方法。|offset|length|style|BOLD|3244431|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|2|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|13|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|14|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|15|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|16|8|@]|9|@]|A|$]]|$1|J|3|K|5|E|7|17|8|@]|9|@]|A|$]]|$1|L|3|M|5|E|7|18|8|@]|9|@]|A|$]]|$1|N|3|O|5|E|7|19|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1C|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1D|8|@$W|1E|X|1F|Y|Z]]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|11|$]]

You need to check for all the constraints of Sudoku :

<ul>
<li>check the sum on each row</li>
<li>check the sum on each column</li>
<li>check for sum on each box</li>
<li>check for duplicate numbers on each row</li>
<li>check for duplicate numbers on each column</li>
<li>check for duplicate numbers on each box</li>
</ul>

that's 6 checks altogether.. using a brute force approach.

Some sort of mathematical optimization can be used if you know the size of the board (ie 3x3 or 9x9)

Edit: explanation for the sum constraint: Checking for the sum first (and stoping if the sum is not 45) is much faster (and simpler) than checking for duplicates. It provides an easy way of discarding a wrong solution.

blocks|key|880302|text|Peter+Norvig有一篇关于解决数独难题(使用python)的很好的文章，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|880303|https://norvig.com/sudoku.html|offset|length|880304|也许这对你想做的事情来说太多了，但不管怎样，这都是一本很棒的书|880305|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|U|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@$D|Q|E|R|1|S]]|A|$]]|$1|F|3|G|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|C]]]]

Peter Norvig has a great article on solving sudoku puzzles (with python),
<a href="https://norvig.com/sudoku.html" rel="nofollow noreferrer">https://norvig.com/sudoku.html</a>
Maybe it's too much for what you want to do, but it's a great read anyway

blocks|key|3245257|text|检查每一行、每一列和每一个框，使其包含数字1-9，没有重复。这里的大多数答案已经讨论了这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3245258|但是如何有效地做到这一点呢？答案:使用循环，如下所示|3245259|result=0;
for+each+entry:
++result+%7C=+1<<(value-1)
return+(result==511);|code-block|syntax|javascript|3245260|每个数字将设置结果的一位。如果所有9个数字都是唯一的，则将设置最低的9位。因此，“检查重复项”测试只是检查所有9位都已设置，这与测试result==511相同。你需要做27次这样的检查。每行、每列和每框一个。|3245261|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Check each row, column and box such that it contains the numbers 1-9 each, with no duplicates. Most answers here already discuss this.

But how to do that efficiently? Answer: Use a loop like

<pre><code>result=0;
for each entry:
 result |= 1&lt;&lt;(value-1)
return (result==511);
</code></pre>

Each number will set one bit of the result. If all 9 numbers are unique, the lowest 9
bits will be set. 
So the "check for duplicates" test is just a check that all 9 bits are set, which is the same as testing result==511.
You need to do 27 of these checks.. one for each row, column, and box.

blocks|key|874948|text|只是想一想:你不需要检查每个3x3方块中的数字吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|874949|我想知道是否有可能在没有正确数独的情况下满足行和列条件|874950|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Just a thought: don't you need to also check the numbers in each 3x3 square? 

I'm trying to figure out if it is possible to have the rows and columns conditions satisfied without having a correct sudoku

blocks|key|3245508|text|这是我的Python解决方案，我很高兴看到它是目前为止最短的一个:)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3245509|代码：|3245510|def+check(sud):
++++zippedsud+=+zip(*sud)

++++boxedsud=[]
++++for+li,line+in+enumerate(sud):
++++++++for+box+in+range(3):
++++++++++++if+not+li+%25+3:+boxedsud.append([])++++#+build+a+new+box+every+3+lines
++++++++++++boxedsud[box+%2B+li/3*3].extend(line[box*3:box*3%2B3])

++++for+li+in+range(9):
++++++++if+[x+for+x+in+[set(sud[li]),+set(zippedsud[li]),+set(boxedsud[li])]+if+x+!=+set(range(1,10))]:
++++++++++++return+False
++++return+True++|code-block|syntax|javascript|3245511|和执行：|3245512|sudoku=[
[7,+5,+1,++8,+4,+3,++9,+2,+6],
[8,+9,+3,++6,+2,+5,++1,+7,+4],+
[6,+4,+2,++1,+7,+9,++5,+8,+3],
[4,+2,+5,++3,+1,+6,++7,+9,+8],
[1,+7,+6,++9,+8,+2,++3,+4,+5],
[9,+3,+8,++7,+5,+4,++6,+1,+2],
[3,+6,+4,++2,+9,+7,++8,+5,+1],
[2,+8,+9,++5,+3,+1,++4,+6,+7],
[5,+1,+7,++4,+6,+8,++2,+3,+9]]

print+check(sudoku)++++++++|3245513|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

This is my solution in Python, I'm glad to see it's the shortest one yet :) 

The code: 

<pre><code>def check(sud):
 zippedsud = zip(*sud)

 boxedsud=[]
 for li,line in enumerate(sud):
 for box in range(3):
 if not li % 3: boxedsud.append([]) # build a new box every 3 lines
 boxedsud[box + li/3*3].extend(line[box*3:box*3+3])

 for li in range(9):
 if [x for x in [set(sud[li]), set(zippedsud[li]), set(boxedsud[li])] if x != set(range(1,10))]:
 return False
 return True 
</code></pre>

And the execution:

<pre><code>sudoku=[
[7, 5, 1, 8, 4, 3, 9, 2, 6],
[8, 9, 3, 6, 2, 5, 1, 7, 4], 
[6, 4, 2, 1, 7, 9, 5, 8, 3],
[4, 2, 5, 3, 1, 6, 7, 9, 8],
[1, 7, 6, 9, 8, 2, 3, 4, 5],
[9, 3, 8, 7, 5, 4, 6, 1, 2],
[3, 6, 4, 2, 9, 7, 8, 5, 1],
[2, 8, 9, 5, 3, 1, 4, 6, 7],
[5, 1, 7, 4, 6, 8, 2, 3, 9]]

print check(sudoku) 
</code></pre>

blocks|key|3245482|text|为每个行、列和正方形创建一个布尔值数组。数组的索引表示放入该行、列或正方形的值。换句话说，如果在第二行第一列中添加5，则应将rows2以及columns1和squares4设置为true，以指示行、列和正方形现在具有5值。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3245483|无论您的原始板是如何表示的，这可以是一种简单且非常快速的方式来检查它的完整性和正确性。只需按数字在电路板上出现的顺序获取它们，然后开始构建此数据结构。当您在电路板中放置数字时，确定在给定行、列或正方形中是否有重复的值就变成了一个O(1)操作。(您还需要检查每个值是否为合法数字:如果他们给您一个空白或过高的数字，您就知道板不完整。)当您到达板的末尾时，您将知道所有的值都是正确的，并且不需要更多的检查。|3245484|有人还指出，您可以使用任何形式的Set来完成此操作。以这种方式排列的数组只是一种特别轻量级和高性能的集合形式，适用于一组小的、连续的、固定的数字。如果你知道你的板的大小，你也可以选择位掩码，但考虑到效率对你来说并不是那么大的问题，这可能有点过于单调乏味。|3245485|entityMap^0|30|1|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|P|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|K|$]]

Create an array of booleans for every row, column, and square. The array's index represents the value that got placed into that row, column, or square. In other words, if you add a 5 to the second row, first column, you would set rows[2][5] to true, along with columns[1][5] and squares[4][5], to indicate that the row, column, and square now have a <code>5</code> value.

Regardless of how your original board is being represented, this can be a simple and very fast way to check it for completeness and correctness. Simply take the numbers in the order that they appear on the board, and begin building this data structure. As you place numbers in the board, it becomes a O(1) operation to determine whether any values are being duplicated in a given row, column, or square. (You'll also want to check that each value is a legitimate number: if they give you a blank or a too-high number, you know that the board is not complete.) When you get to the end of the board, you'll know that all the values are correct, and there is no more checking required.

Someone also pointed out that you can use any form of Set to do this. Arrays arranged in this manner are just a particularly lightweight and performant form of a Set that works well for a small, consecutive, fixed set of numbers. If you know the size of your board, you could also choose to do bit-masking, but that's probably a little overly tedious considering that efficiency isn't that big a deal to you.

blocks|key|4090214|text|创建单元格集合，每个集合包含9个单元格，并为垂直列、水平行和3x3正方形创建集合。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4090215|然后，对于每个单元格，只需识别它所属的集合并对其进行分析。|4090216|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Create cell sets, where each set contains 9 cells, and create sets for vertical columns, horizontal rows, and 3x3 squares.

Then for each cell, simply identify the sets it's part of and analyze those.

blocks|key|4090317|text|您可以将集合(行、列、框)中的所有值提取到一个列表中，对其进行排序，然后与'(1，2，3，4，5，6，7，8，9)进行比较|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4090318|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You could extract all values in a set (row, column, box) into a list, sort it, then compare to '(1, 2, 3, 4, 5, 6, 7, 8, 9)

blocks|key|3245123|text|我曾经为一个班级项目这样做过一次。我总共使用了27个集合来表示每个行、列和框。我会在将数字添加到每个集合时检查它们(每次放置一个数字都会导致该数字被添加到3个集合、一行、一列和一个框中)，以确保用户只输入数字1-9。填充集合的唯一方法是正确地填充唯一的数字。如果所有27组都填满了，那么谜题就解决了。设置从用户界面到27个集合的映射有点单调乏味，但使其余的逻辑实现起来轻而易举。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3245124|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I did this once for a class project. I used a total of 27 sets to represent each row, column and box. I'd check the numbers as I added them to each set (each placement of a number causes the number to be added to 3 sets, a row, a column, and a box) to make sure the user only entered the digits 1-9. The only way a set could get filled is if it was properly filled with unique digits. If all 27 sets got filled, the puzzle was solved. Setting up the mappings from the user interface to the 27 sets was a bit tedious, but made the rest of the logic a breeze to implement.

blocks|key|4090065|text|检查以下内容将是非常有趣的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4090066|when+the+sum+of+each+row/column/box+equals+n*(n%2B1)/2
and+the+product+equals+n!
with+n+=+number+of+rows+or+columns|code-block|syntax|javascript|4090067|这就满足了数独游戏的规则。因为这将允许一个O(n%5E2)的算法，对正确的单元进行求和和相乘。|4090068|看n=+9，和应该是45，乘积是362880。|4090069|你可以这样做：|4090070|for+i+=+0+to+n-1+do
++boxsum[i]+:=+0;
++colsum[i]+:=+0;
++rowsum[i]+:=+0;
++boxprod[i]+:=+1;
++colprod[i]+:=+1;
++rowprod[i]+:=+1;++++
end;

for+i+=+0+to+n-1+do
++for+j+=+0+to+n-1+do
++++box+:=+(i+div+n%5E1/2)+%2B+(j+div+n%5E1/2)*n%5E1/2;
++++boxsum[box]+:=+boxsum[box]+%2B+cell[i,j];
++++boxprod[box]+:=+boxprod[box]+*+cell[i,j];
++++colsum[i]+:=+colsum[i]+%2B+cell[i,j];
++++colprod[i]+:=+colprod[i]+*+cell[i,j];
++++rowsum[j]+:=+colsum[j]+%2B+cell[i,j];
++++rowprod[j]+:=+colprod[j]+*+cell[i,j];
+++end;
end;

for+i+=+0+to+n-1+do
++if+boxsum[i]+<>+45
++or+colsum[i]+<>+45
++or+rowsum[i]+<>+45
++or+boxprod[i]+<>+362880
++or+colprod[i]+<>+362880
++or+rowprod[i]+<>+362880
+++return+false;|4090071|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

It would be very interesting to check if:

<pre><code>when the sum of each row/column/box equals n*(n+1)/2
and the product equals n!
with n = number of rows or columns
</code></pre>

this suffices the rules of a sudoku. Because that would allow for an algorithm of O(n^2), summing and multiplying the correct cells.

Looking at n = 9, the sums should be 45, the products 362880.

You would do something like:

<pre><code>for i = 0 to n-1 do
 boxsum[i] := 0;
 colsum[i] := 0;
 rowsum[i] := 0;
 boxprod[i] := 1;
 colprod[i] := 1;
 rowprod[i] := 1; 
end;

for i = 0 to n-1 do
 for j = 0 to n-1 do
 box := (i div n^1/2) + (j div n^1/2)*n^1/2;
 boxsum[box] := boxsum[box] + cell[i,j];
 boxprod[box] := boxprod[box] * cell[i,j];
 colsum[i] := colsum[i] + cell[i,j];
 colprod[i] := colprod[i] * cell[i,j];
 rowsum[j] := colsum[j] + cell[i,j];
 rowprod[j] := colprod[j] * cell[i,j];
 end;
end;

for i = 0 to n-1 do
 if boxsum[i] &lt;&gt; 45
 or colsum[i] &lt;&gt; 45
 or rowsum[i] &lt;&gt; 45
 or boxprod[i] &lt;&gt; 362880
 or colprod[i] &lt;&gt; 362880
 or rowprod[i] &lt;&gt; 362880
 return false;
</code></pre>

blocks|key|4090410|text|前段时间，我写了一个数独检查器，检查每行重复的数字，每列重复的数字和每个盒子上的重复数字。不过，如果有人能想出几行Linq代码，我会很高兴的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4090411|char+VerifySudoku(char+grid[81])
{
++++for+(char+r+=+0;+r+<+9;+%2B%2Br)
++++{
++++++++unsigned+int+bigFlags+=+0;

++++++++for+(char+c+=+0;+c+<+9;+%2B%2Bc)
++++++++{
++++++++++++unsigned+short+buffer+=+r/3*3%2Bc/3;

++++++++++++++++++++++++//+check+horizontally
++++++++++++bitFlags+%7C=+1+<<+(27-grid[(r<<3)%2Br%2Bc])+
++++++++++++++++++++++++//+check+vertically
+++++++++++++++++++++%7C++1+<<+(18-grid[(c<<3)%2Bc%2Br])
++++++++++++++++++++++++//+check+subgrids
+++++++++++++++++++++%7C++1+<<+(9-grid[(buffer<<3)%2Bbuffer%2Br%253*3%2Bc%253]);

++++++++}

++++++++if+(bitFlags+!=+0x7ffffff)
++++++++++++return+0;+//+invalid
++++}

++++return+1;+//+valid
}|code-block|syntax|javascript|4090412|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Some time ago, I wrote a sudoku checker that checks for duplicate number on each row, duplicate number on each column &amp; duplicate number on each box. I would love it if someone could come up one with like a few lines of Linq code though.

<pre><code>char VerifySudoku(char grid[81])
{
 for (char r = 0; r &lt; 9; ++r)
 {
 unsigned int bigFlags = 0;

 for (char c = 0; c &lt; 9; ++c)
 {
 unsigned short buffer = r/3*3+c/3;

 // check horizontally
 bitFlags |= 1 &lt;&lt; (27-grid[(r&lt;&lt;3)+r+c]) 
 // check vertically
 | 1 &lt;&lt; (18-grid[(c&lt;&lt;3)+c+r])
 // check subgrids
 | 1 &lt;&lt; (9-grid[(buffer&lt;&lt;3)+buffer+r%3*3+c%3]);

 }

 if (bitFlags != 0x7ffffff)
 return 0; // invalid
 }

 return 1; // valid
}
</code></pre>

blocks|key|880478|text|如果和的和行/列的乘法等于右数字45/362880|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|880479|entityMap^0|2|1|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

if the sum and the multiplication of a row/col equals to the right number 45/362880

blocks|key|4090910|text|首先，你需要做一个布尔值，“正确”。然后，创建一个for循环，如前所述。循环和后面的代码(在java中)如上所述，其中field是一个等边的2D数组，col是另一个具有相同维度的数组，l是一个1D数组：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4090911|for(int+i=0;+i<field.length();+i%2B%2B){
++++for(int+j=0;+j<field[i].length;+j%2B%2B){
++++++++if(field[i][j]>9%7C%7Cfield[i][j]<1){
++++++++++++checking=false;
++++++++++++break;
++++++++}
++++++++else{
++++++++++++col[field[i].length()-j][i]=field[i][j];
++++++++}
++++}
}|code-block|syntax|javascript|4090912|我不知道检查3x3框的确切算法，但您应该检查字段中的所有行，并在另一个for循环中使用"/*array+name+goes+here*/[i].contains(1)&&/*array+name+goes+here*/[i].contains(2)“(一直持续到行的长度)。|offset|length|style|CODE|4090913|entityMap^0|0|0|18|28|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

First, you would need to make a boolean, "correct". Then, make a for loop, as previously stated. The code for the loop and everything afterwards (in java) is as stated, where field is a 2D array with equal sides, col is another one with the same dimensions, and l is a 1D one:

<pre><code>for(int i=0; i&lt;field.length(); i++){
 for(int j=0; j&lt;field[i].length; j++){
 if(field[i][j]&gt;9||field[i][j]&lt;1){
 checking=false;
 break;
 }
 else{
 col[field[i].length()-j][i]=field[i][j];
 }
 }
}
</code></pre>

I don't know the exact algorithim to check the 3x3 boxes, but you should check all the rows in field and col with "<code>/*array name goes here*/[i].contains(1)&amp;&amp;/*array name goes here*/[i].contains(2)</code>" (continues until you reach the length of a row) inside another for loop.

blocks|key|3245647|text|在Python中有一个很好的可读性方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3245648|from+itertools+import+chain++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

def+valid(puzzle):+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++def+get_block(x,y):++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++return+chain(*[puzzle[i][3*x:3*x%2B3]+for+i+in+range(3*y,+3*y%2B3)])+++++++++++++++++++++++++++++++++++++++++++++++
++++rows+=+[set(row)+for+row+in+puzzle]++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++columns+=+[set(column)+for+column+in+zip(*puzzle)]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++blocks+=+[set(get_block(x,y))+for+x+in+range(0,3)+for+y+in+range(0,3)]+++++++++++++++++++++++++++++++++++++++++++++
++++return+all(map(lambda+s:+s+==+set([1,2,3,4,5,6,7,8,9]),+rows+%2B+columns+%2B+blocks))+++++++++|code-block|syntax|javascript|3245649|每个3x3正方形被称为一个块，在3x3网格中有9个。假设难题是作为列表的列表输入的，每个内部列表是一行。|3245650|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Here's a nice readable approach in Python:

<pre><code>from itertools import chain 

def valid(puzzle): 
 def get_block(x,y): 
 return chain(*[puzzle[i][3*x:3*x+3] for i in range(3*y, 3*y+3)]) 
 rows = [set(row) for row in puzzle] 
 columns = [set(column) for column in zip(*puzzle)] 
 blocks = [set(get_block(x,y)) for x in range(0,3) for y in range(0,3)] 
 return all(map(lambda s: s == set([1,2,3,4,5,6,7,8,9]), rows + columns + blocks)) 
</code></pre>

Each 3x3 square is referred to as a block, and there are 9 of them in a 3x3 grid. It is assumed as the puzzle is input as a list of list, with each inner list being a row.

blocks|key|4090115|text|假设int+sudoku0..8,0..8是sudoku域。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4090116|bool+CheckSudoku(int[,]+sudoku)
{
++++int+flag+=+0;

//+Check+rows
for(int+row+=+0;+row+<+9;+row%2B%2B)
{
++++flag+=+0;
++++for+(int+col+=+0;+col+<+9;+col%2B%2B)
++++{
++++++++//+edited+:+check+range+step+(see+comments)
++++++++if+((sudoku[row,+col]+<+1)%7C%7C(sudoku[row,+col]+>+9))+
++++++++{
++++++++++++return+false;
++++++++}

++++++++//+if+n-th+bit+is+set..+but+you+can+use+a+bool+array+for+readability
++++++++if+((flag+&+(1+<<+sudoku[row,+col]))+!=+0)+
++++++++{
++++++++++++return+false;
++++++++}

++++++++//+set+the+n-th+bit
++++++++flag+%7C=+(1+<<+sudoku[row,+col]);+
++++}
}

//+Check+columns
for(int+col=+0;+col+<+9;+col%2B%2B)
{
++++flag+=+0;
++++for+(int+row+=+0;+row+<+9;+row%2B%2B)
++++{
++++++++if+((flag+&+(1+<<+sudoku[row,+col]))+!=+0)
++++++++{
++++++++++++return+false;
++++++++}
++++++++flag+%7C=+(1+<<+sudoku[row,+col]);
++++}
}

//+Check+3x3+boxes
for(int+box=+0;+box+<+9;+box%2B%2B)
{
++++flag+=+0;
++++for+(int+ofs+=+0;+ofs+<+9;+ofs%2B%2B)
++++{
++++++++int+col+=+(box+%25+3)+*+3;
++++++++int+row+=+((int)(box+/+3))+*+3;

++++++++if+((flag+&+(1+<<+sudoku[row,+col]))+!=+0)
++++++++{
++++++++++++return+false;
++++++++}
++++++++flag+%7C=+(1+<<+sudoku[row,+col]);
++++}
}
return+true;|code-block|syntax|javascript|4090117|}|4090118|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Let's say int sudoku[0..8,0..8] is the sudoku field.

<pre><code>bool CheckSudoku(int[,] sudoku)
{
 int flag = 0;

// Check rows
for(int row = 0; row &lt; 9; row++)
{
 flag = 0;
 for (int col = 0; col &lt; 9; col++)
 {
 // edited : check range step (see comments)
 if ((sudoku[row, col] &lt; 1)||(sudoku[row, col] &gt; 9)) 
 {
 return false;
 }

 // if n-th bit is set.. but you can use a bool array for readability
 if ((flag &amp; (1 &lt;&lt; sudoku[row, col])) != 0) 
 {
 return false;
 }

 // set the n-th bit
 flag |= (1 &lt;&lt; sudoku[row, col]); 
 }
}

// Check columns
for(int col= 0; col &lt; 9; col++)
{
 flag = 0;
 for (int row = 0; row &lt; 9; row++)
 {
 if ((flag &amp; (1 &lt;&lt; sudoku[row, col])) != 0)
 {
 return false;
 }
 flag |= (1 &lt;&lt; sudoku[row, col]);
 }
}

// Check 3x3 boxes
for(int box= 0; box &lt; 9; box++)
{
 flag = 0;
 for (int ofs = 0; ofs &lt; 9; ofs++)
 {
 int col = (box % 3) * 3;
 int row = ((int)(box / 3)) * 3;

 if ((flag &amp; (1 &lt;&lt; sudoku[row, col])) != 0)
 {
 return false;
 }
 flag |= (1 &lt;&lt; sudoku[row, col]);
 }
}
return true;
</code></pre>

}

blocks|key|23020|text|让我们假设你的棋盘从1到n。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|23021|我们将创建一个验证数组，填充它，然后验证它。|23022|grid+[0-(n-1)][0-(n-1)];+//this+is+the+input+grid
//each+verification+takes+n%5E2+bits,+so+three+verifications+gives+us+3n%5E2
boolean+VArray+(3*n*n)+//make+sure+this+is+initialized+to+false


for+i+=+0+to+n
+for+j+=+0+to+n
++/*
+++each+coordinate+consists+of+three+parts
+++row/col/box+start+pos,+index+offset,+val+offset+
++*/

++//to+validate+rows
++VArray(+(0)+++++%2B+(j*n)+++++++++++++++++++++++++++++%2B+(grid[i][j]-1)+)+=+1
++//to+validate+cols
++VArray(+(n*n)+++%2B+(i*n)+++++++++++++++++++++++++++++%2B+(grid[i][j]-1)+)+=+1
++//to+validate+boxes
++VArray(+(2*n*n)+%2B+(3*(floor+(i/3)*n)%2B+floor(j/3)*n)+%2B+(grid[i][j]-1)+)+=+1
+next++++
next

if+every+array+value+is+true+then+the+solution+is+correct.+|code-block|syntax|javascript|23023|我认为这会起作用，尽管我确信我在其中犯了几个愚蠢的错误。我甚至可能完全错过了这条船。|23024|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Let's assume that your board goes from 1 - n. 

We'll create a verification array, fill it and then verify it. 

<pre><code>grid [0-(n-1)][0-(n-1)]; //this is the input grid
//each verification takes n^2 bits, so three verifications gives us 3n^2
boolean VArray (3*n*n) //make sure this is initialized to false


for i = 0 to n
 for j = 0 to n
 /*
 each coordinate consists of three parts
 row/col/box start pos, index offset, val offset 
 */

 //to validate rows
 VArray( (0) + (j*n) + (grid[i][j]-1) ) = 1
 //to validate cols
 VArray( (n*n) + (i*n) + (grid[i][j]-1) ) = 1
 //to validate boxes
 VArray( (2*n*n) + (3*(floor (i/3)*n)+ floor(j/3)*n) + (grid[i][j]-1) ) = 1
 next 
next

if every array value is true then the solution is correct. 
</code></pre>

I think that will do the trick, although i'm sure i made a couple of stupid mistakes in there. I might even have missed the boat entirely.

blocks|key|3245057|text|array+=+[1,2,3,4,5,6,7,8,9]++
sudoku+=+int+[][]
puzzle+=+9+#9x9
columns+=+map+[]
units+=+map+[]+#+box++++
unit_l+=+3+#+box+width/height
check_puzzle()++++


def+strike_numbers(line,+line_num,+columns,+units,+unit_l):
++++count+=+0
++++for+n+in+line:
++++++++#+check+which+unit+we're+in
++++++++unit+=+ceil(n+/+unit_l)+%2B+ceil(line_num+/+unit_l)+#+this+line+is+wrong+-+rushed
++++++++if+units[unit].contains(n):+#is+n+in+unit+already?
+++++++++++++return+columns,+units,+1
++++++++units[unit].add(n)
++++++++if+columns[count].contains(n):+#is+n+in+column+already?
++++++++++++return+columns,+units,+1
++++++++columns[count].add(n)
++++++++line.remove(n)+#remove+num+from+temp+row
++++return+columns,+units,+line.length+#+was+a+number+not+eliminated?

def+check_puzzle(columns,+sudoku,+puzzle,+array,+units):
++++for+(i=0;i<+puzzle;i%2B%2B):
++++++++columns,+units,+left_over+=+strike_numbers(sudoku[i],+i,+columns,+units)+#+iterate+through+rows
++++++++if+(left_over+>+0):+return+false|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3245058|在没有彻底检查的情况下，这应该是可行的(只需要一点调试)，而且只需要循环两次。O(n%5E2)而不是O(3(n%5E2))|unstyled|3245059|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>array = [1,2,3,4,5,6,7,8,9] 
sudoku = int [][]
puzzle = 9 #9x9
columns = map []
units = map [] # box 
unit_l = 3 # box width/height
check_puzzle() 


def strike_numbers(line, line_num, columns, units, unit_l):
 count = 0
 for n in line:
 # check which unit we're in
 unit = ceil(n / unit_l) + ceil(line_num / unit_l) # this line is wrong - rushed
 if units[unit].contains(n): #is n in unit already?
 return columns, units, 1
 units[unit].add(n)
 if columns[count].contains(n): #is n in column already?
 return columns, units, 1
 columns[count].add(n)
 line.remove(n) #remove num from temp row
 return columns, units, line.length # was a number not eliminated?

def check_puzzle(columns, sudoku, puzzle, array, units):
 for (i=0;i&lt; puzzle;i++):
 columns, units, left_over = strike_numbers(sudoku[i], i, columns, units) # iterate through rows
 if (left_over &gt; 0): return false
</code></pre>

Without thoroughly checking, off the top of my head, this should work (with a bit of debugging) while only looping twice. O(n^2) instead of O(3(n^2))

blocks|key|23228|text|这是数学教授J.F.克鲁克的论文：A+Pencil-and-Paper+Algorithm+for+Solving+Sudoku+Puzzles|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|23229|这篇论文发表于2009年4月，作为明确的数独解决方案得到了大量宣传(在谷歌上搜索"J.F.Crook数独“)。|23230|除了算法之外，还有一个数学证明证明了算法是有效的(教授承认他对数独并不感兴趣，所以他在论文中加入了一些数学，以使它更有趣)。|23231|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ams.org/notices/200904/rtx090400460p.pdf^0|H|1J|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

Here is paper by math professor J.F. Crook: <a href="http://www.ams.org/notices/200904/rtx090400460p.pdf" rel="nofollow noreferrer">A Pencil-and-Paper Algorithm for Solving Sudoku Puzzles</a> 

This paper was published in April 2009 and it got lots of publicity as definite Sudoku solution (check google for "J.F.Crook Sudoku" ). 

Besides algorithm, there is also a mathematical proof that algorithm works (professor admitted that he does not find Sudoku very interesting, so he threw some math in paper to make it more fun).

blocks|key|880468|text|我会编写一个接口，该接口具有接收sudoku字段的函数，如果是解决方案，则返回true/false。然后将约束实现为每个约束的单个验证类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|880469|为了验证，只需迭代所有约束类，当所有约束类都通过时，sudoku是正确的。为了加快速度，将最有可能失败的结果放在最前面，并在第一个指向无效字段的结果中停止。|880470|非常通用的模式。;-)|880471|当然，您可以对其进行增强，以提供可能是错误的字段的提示，等等。|880472|第一个约束，只需检查是否所有字段都已填写。(简单循环)第二次检查所有数字是否都在每个块中(嵌套循环)第三次检查完整的行和列(几乎与上面的过程相同，但访问方案不同)|880473|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

I'd write an interface that has functions that receive the sudoku field and returns true/false if it's a solution.
Then implement the constraints as single validation classes per constraint.

To verify just iterate through all constraint classes and when all pass the sudoku is correct. To speedup put the ones that most likely fail to the front and stop in the first result that points to invalid field.

Pretty generic pattern. ;-)

You can of course enhance this to provide hints which field is presumably wrong and so on.

First constraint, just check if all fields are filled out. (Simple loop)
Second check if all numbers are in each block (nested loops)
Third check for complete rows and columns (almost same procedure as above but different access scheme)

blocks|key|4090854|text|这是我用C写的，每个方块只传一次。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4090855|int+checkSudoku(int+board[])+{
++int+i;
++int+check[13]+=+{+0+};

++for+(i+=+0;+i+<+81;+i%2B%2B)+{
++++if+(i+%25+9+==+0)+{
++++++check[9]+=+0;
++++++if+(i+%25+27+==+0)+{
++++++++check[10]+=+0;
++++++++check[11]+=+0;
++++++++check[12]+=+0;
++++++}
++++}

++++if+(check[i+%25+9]+&+(1+<<+board[i]))+{
++++++return+0;
++++}
++++check[i+%25+9]+%7C=+(1+<<+board[i]);

++++if+(check[9]+&+(1+<<+board[i]))+{
++++++return+0;
++++}
++++check[9]+%7C=+(1+<<+board[i]);

++++if+(i+%25+9+<+3)+{
++++++if+(check[10]+&+(1+<<+board[i]))+{
++++++++return+0;
++++++}
++++++check[10]+%7C=+(1+<<+board[i]);
++++}+else+if+(i+%25+9+<+6)+{
++++++if+(check[11]+&+(1+<<+board[i]))+{
++++++++return+0;
++++++}
++++++check[11]+%7C=+(1+<<+board[i]);
++++}+else+{
++++++if+(check[12]+&+(1+<<+board[i]))+{
++++++++return+0;
++++++}
++++++check[12]+%7C=+(1+<<+board[i]);
++++}
++}
}|code-block|syntax|javascript|4090856|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is mine in C. Only pass each square once.

<pre><code>int checkSudoku(int board[]) {
 int i;
 int check[13] = { 0 };

 for (i = 0; i &lt; 81; i++) {
 if (i % 9 == 0) {
 check[9] = 0;
 if (i % 27 == 0) {
 check[10] = 0;
 check[11] = 0;
 check[12] = 0;
 }
 }

 if (check[i % 9] &amp; (1 &lt;&lt; board[i])) {
 return 0;
 }
 check[i % 9] |= (1 &lt;&lt; board[i]);

 if (check[9] &amp; (1 &lt;&lt; board[i])) {
 return 0;
 }
 check[9] |= (1 &lt;&lt; board[i]);

 if (i % 9 &lt; 3) {
 if (check[10] &amp; (1 &lt;&lt; board[i])) {
 return 0;
 }
 check[10] |= (1 &lt;&lt; board[i]);
 } else if (i % 9 &lt; 6) {
 if (check[11] &amp; (1 &lt;&lt; board[i])) {
 return 0;
 }
 check[11] |= (1 &lt;&lt; board[i]);
 } else {
 if (check[12] &amp; (1 &lt;&lt; board[i])) {
 return 0;
 }
 check[12] |= (1 &lt;&lt; board[i]);
 }
 }
}
</code></pre>

blocks|key|880622|text|下面是我为此所做的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|880623|boolean+checkers=true;
String+checking="";
++++if(a.length/3==1){}
++++else{
+++++++for(int+l=1;+l<a.length/3;+l%2B%2B){
++++++++++++for(int+n=0;n<3*l;n%2B%2B){
++++++++++++++++for(int+lm=1;+lm<a[n].length/3;+lm%2B%2B){
++++++++++++++++++++for(int+m=0;m<3*l;m%2B%2B){
++++++++++++++++++++System.out.print("++++"%2Ba[n][m]);
++++++++++++++++++++if(a[n][m]<=0){
++++++++++++++++++++System.out.print("++++++++(Values+must+be+positive!)++++++++");
++++++++++++++++++++}
++++++++++++++++++++if(n==0){
++++++++++++++++++++++++if(m!=0){
++++++++++++++++++++++++checking%2B=",+"%2Ba[n][m];
++++++++++++++++++++}
++++++++++++++++++++else{
++++++++++++++++++++++++checking%2B=a[n][m];
++++++++++++++++++++}
++++++++++++++++}
++++++++++++++++else{
++++++++++++++++++++checking%2B=",+"%2Ba[n][m];
++++++++++++++++}
++++++++++++}
++++++++++++++++++++}
++++++++++++System.out.print("++++++++"%2Bchecking);
++++++++++++System.out.println();
++++++++++++++++}
+++++++}
++++++++++++for+(int+i=1;i<=a.length*a[1].length;i%2B%2B){
++++++++if(checking.contains(Integer.toString(i))){

++++++++}
++++++++else{
++++++++++++checkers=false;
++++++++}
++++++++++++}
++++++++}
++++checkers=checkCol(a);
++++if(checking.contains("-")&&!checking.contains("--")){
++++++++checkers=false;
++++}
++++System.out.println();
++++if(checkers==true){
++++++++System.out.println("This+is+correct!+YAY!");
++++}
++++else{
++++++++System.out.println("Sorry,+it's+not+right.+:-(");
++++}
}
private+static+boolean+checkCol(int[][]a){
++++boolean+checkers=true;
++++int[][]col=new+int[][]{{0,0,0},{0,0,0},{0,0,0}};
++++for(int+i=0;+i<a.length;+i%2B%2B){
++++++++for(int+j=0;+j<a[i].length;+j%2B%2B){
++++++++++++if(a[i][j]>9%7C%7Ca[i][j]<1){
++++++++++++++++checkers=false;
++++++++++++++++break;
++++++++++++}
++++++++++++else{
++++++++++++++++col[a[i].length-j][i]=a[i][j];
++++++++++++}
++++++++}
++++}
++++String+alia="";
++++for(int+i=0;+i<col.length;+i%2B%2B){
++++++++for(int+j=1;+j<=col[i].length;+j%2B%2B){
++++++++++++alia=a[i].toString();
++++++++++++if(alia.contains(""%2Bj)){
++++++++++++++++alia=col[i].toString();
++++++++++++++++if(alia.contains(""%2Bj)){}
++++++++++++++++else{
++++++++++++++++++++checkers=false;
++++++++++++++++}+++
++++++++++++}
++++++++++++else{
++++++++++++++++checkers=false;
++++++++++++}
++++++++}
++++}
++++return+checkers;
}|code-block|syntax|javascript|880624|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is what I just did for this:

<pre><code>boolean checkers=true;
String checking="";
 if(a.length/3==1){}
 else{
 for(int l=1; l&lt;a.length/3; l++){
 for(int n=0;n&lt;3*l;n++){
 for(int lm=1; lm&lt;a[n].length/3; lm++){
 for(int m=0;m&lt;3*l;m++){
 System.out.print(" "+a[n][m]);
 if(a[n][m]&lt;=0){
 System.out.print(" (Values must be positive!) ");
 }
 if(n==0){
 if(m!=0){
 checking+=", "+a[n][m];
 }
 else{
 checking+=a[n][m];
 }
 }
 else{
 checking+=", "+a[n][m];
 }
 }
 }
 System.out.print(" "+checking);
 System.out.println();
 }
 }
 for (int i=1;i&lt;=a.length*a[1].length;i++){
 if(checking.contains(Integer.toString(i))){

 }
 else{
 checkers=false;
 }
 }
 }
 checkers=checkCol(a);
 if(checking.contains("-")&amp;&amp;!checking.contains("--")){
 checkers=false;
 }
 System.out.println();
 if(checkers==true){
 System.out.println("This is correct! YAY!");
 }
 else{
 System.out.println("Sorry, it's not right. :-(");
 }
}
private static boolean checkCol(int[][]a){
 boolean checkers=true;
 int[][]col=new int[][]{{0,0,0},{0,0,0},{0,0,0}};
 for(int i=0; i&lt;a.length; i++){
 for(int j=0; j&lt;a[i].length; j++){
 if(a[i][j]&gt;9||a[i][j]&lt;1){
 checkers=false;
 break;
 }
 else{
 col[a[i].length-j][i]=a[i][j];
 }
 }
 }
 String alia="";
 for(int i=0; i&lt;col.length; i++){
 for(int j=1; j&lt;=col[i].length; j++){
 alia=a[i].toString();
 if(alia.contains(""+j)){
 alia=col[i].toString();
 if(alia.contains(""+j)){}
 else{
 checkers=false;
 } 
 }
 else{
 checkers=false;
 }
 }
 }
 return checkers;
}
</code></pre>

blocks|key|4091028|text|您可以通过以下两种类似的方式检查数独是否已解决：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4091029|4091030|检查编号在每行、每列和每块中是否唯一。|unordered-list-item|4091031|4091032|一个天真的解决方案是遍历每个正方形，并检查该数字在该数字所占的行块和列块中是否唯一。|4091033|但还有一种更好的方法。|4091034|如果每行、每列和每一块都包含数字(1槽9)的排列，则|4091035|数独被求解。|4091036|4091037|这只需要检查每一行、每一列和每一块，而不是对每个数字都这样做。一个简单的实现是拥有一个数字为1到9的位域，并在迭代列、行和块时删除它们。如果您尝试删除缺少的数字，或者如果完成时该字段不为空，则数独不能正确解决。|4091038|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|U|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|V|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|X|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Y|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|Z|8|@]|9|@]|A|$]]|$1|M|3|N|5|E|7|10|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|11|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|12|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|S|$]]

You can check if sudoku is solved, in these two similar ways:

<ul>
<li>Check if the number is unique in each row, column and block. </li>
</ul>

A naive solution would be to iterate trough every square and check if the number is unique in the row, column block that number occupies.

But there is a better way.

<ul>
<li>Sudoku is solved if every row, column and block contains a permutation of the numbers (1 trough 9)</li>
</ul>

This only requires to check every row, column and block, instead of doing that for every number. A simple implementation would be to have a bitfield of numbers 1 trough 9 and remove them when you iterate the columns, rows and blocks. If you try to remove a missing number or if the field isn't empty when you finish then sudoku isn't correctly solved.

blocks|key|23743|text|在Swift中有一个非常简洁的版本，它只使用in数组来跟踪9个数字的组，并且只在sudoku上迭代一次。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|23744|import+UIKit

func+check(_+sudoku:[[Int]])+->+Bool+{

++++var+groups+=+Array(repeating:+0,+count:+27)

++++for+x+in+0...8+{
++++++++for+y+in+0...8+{
++++++++++++groups[x]+%2B=+1+<<+sudoku[x][y]+//+Column+(group+0+-+8)
++++++++++++groups[y+%2B+9]+%2B=+1+<<+sudoku[x][y]+//+Row+(group+9+-+17)
++++++++++++groups[(x+%2B+y+*+9)+/+9+%2B+18]+%2B=+1+<<+sudoku[x][y]+//+Box+(group+18+-+27)
++++++++}
++++}

++++return+groups.filter{+$0+!=+1022+}.count+==+0
}

let+sudoku+=+[
++++[7,+5,+1,++8,+4,+3,++9,+2,+6],
++++[8,+9,+3,++6,+2,+5,++1,+7,+4],
++++[6,+4,+2,++1,+7,+9,++5,+8,+3],
++++[4,+2,+5,++3,+1,+6,++7,+9,+8],
++++[1,+7,+6,++9,+8,+2,++3,+4,+5],
++++[9,+3,+8,++7,+5,+4,++6,+1,+2],
++++[3,+6,+4,++2,+9,+7,++8,+5,+1],
++++[2,+8,+9,++5,+3,+1,++4,+6,+7],
++++[5,+1,+7,++4,+6,+8,++2,+3,+9]
]

if+check(sudoku)+{
++++print("Pass")
}+else+{
++++print("Fail")
}|code-block|syntax|javascript|23745|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's a very concise version in Swift, that only uses an array of Ints to track the groups of 9 numbers, and only iterates over the sudoku once. 

<pre><code>import UIKit

func check(_ sudoku:[[Int]]) -&gt; Bool {

 var groups = Array(repeating: 0, count: 27)

 for x in 0...8 {
 for y in 0...8 {
 groups[x] += 1 &lt;&lt; sudoku[x][y] // Column (group 0 - 8)
 groups[y + 9] += 1 &lt;&lt; sudoku[x][y] // Row (group 9 - 17)
 groups[(x + y * 9) / 9 + 18] += 1 &lt;&lt; sudoku[x][y] // Box (group 18 - 27)
 }
 }

 return groups.filter{ $0 != 1022 }.count == 0
}

let sudoku = [
 [7, 5, 1, 8, 4, 3, 9, 2, 6],
 [8, 9, 3, 6, 2, 5, 1, 7, 4],
 [6, 4, 2, 1, 7, 9, 5, 8, 3],
 [4, 2, 5, 3, 1, 6, 7, 9, 8],
 [1, 7, 6, 9, 8, 2, 3, 4, 5],
 [9, 3, 8, 7, 5, 4, 6, 1, 2],
 [3, 6, 4, 2, 9, 7, 8, 5, 1],
 [2, 8, 9, 5, 3, 1, 4, 6, 7],
 [5, 1, 7, 4, 6, 8, 2, 3, 9]
]

if check(sudoku) {
 print("Pass")
} else {
 print("Fail")
}
</code></pre>

blocks|key|4091085|text|您可以进行的一个小优化是，您可以在O(n)时间内检查行、列或框中的重复项，而不是O(n%5E2)：当您迭代一组数字时，将每个数字添加到一个哈希集。根据语言的不同，您实际上可能能够使用真正的哈希集，即恒定时间的查找和插入；然后，通过查看插入是否成功，可以在同一步骤中检查重复项。这是代码中的一个小改进，但从O(n%5E2)到O(n)是一个重要的优化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4091086|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

One minor optimization you can make is that you can check for duplicates in a row, column, or box in O(n) time rather than O(n^2): as you iterate through the set of numbers, you add each one to a hashset. Depending on the language, you may actually be able to use a true hashset, which is constant time lookup and insertion; then checking for duplicates can be done in the same step by seeing if the insertion was successful or not. It's a minor improvement in the code, but going from O(n^2) to O(n) is a significant optimization.

Does anyone know a simple algorithm to check if a Sudoku-Configuration is valid? The simplest algorithm I came up with is (for a board of size n) in Pseudocode

<pre><code>for each row
 for each number k in 1..n
 if k is not in the row (using another for-loop)
 return not-a-solution

..do the same for each column
</code></pre>

But I'm quite sure there must be a better (in the sense of more elegant) solution. Efficiency is quite unimportant.

A cool algorithm to check a Sudoku field?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

有没有人知道一个简单的算法来检查数独配置是否有效？我想出的最简单的算法是(对于大小为n的棋盘)用伪代码for each row  for each number k in 1..n    if k is not in the row (using another for-loop)      return not-a-solution..do the same for each column但我非

问检查数独字段的一个很酷的算法？
EN

回答 24

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问检查数独字段的一个很酷的算法？EN

回答 24

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问检查数独字段的一个很酷的算法？
EN