Wie viele Bits sind mindestens erforderlich, um ein Sudoku-Puzzle zu speichern?

Hinweis: Hierbei handelt es sich um das Standard-9x9-Sudoku-Puzzle. Die Lösung muss nur gelöste, rechtliche Rätsel unterstützen . Eine Lösung muss also keine leeren Zellen unterstützen und kann sich auf die Eigenschaften eines gelösten Sudoku-Puzzles verlassen.

Ich fragte mich, aber mir fiel keine Antwort ein, mit der ich zufrieden war. Eine naive Lösung würde ein Byte für jede Zelle (81 Zellen) verwenden, was insgesamt 648 Bits entspricht. Eine komplexere Lösung würde das gesamte Sudoku-Puzzle in einer Zahl zur Basis 9 (eine Ziffer pro Zelle) und ⌈ log 2 ( 9 81 ) ) ) = $\lceil\log_2(9^{81}))\rceil = 257$ Bits erfordern .

Es kann jedoch noch verbessert werden. Wenn Sie beispielsweise 8 der 9 Zahlen in einem 3x3-Subgrid kennen, können Sie trivial auf die 9. schließen. Sie können diese Überlegungen bis zu dem Punkt fortsetzen, an dem diese Frage auf die Anzahl der eindeutigen gelösten Sudokus hinausläuft. Jetzt können Sie eine große Nachschlagetabelle verwenden, die jede Binärzahl einem Sudoku-Puzzle zuordnet, aber das wäre keine brauchbare Lösung.

Also meine Frage:

Was ist ohne Verwendung einer Nachschlagetabelle die Mindestanzahl von Bits, die zum Speichern eines Sudoku-Puzzles erforderlich sind, und mit welchem ​​Algorithmus?

Entspricht der Antwort von Ratchet Freak, wenn Sie die nicht mit einem Stern versehenen Zellen in der folgenden Matrix jeweils in einem 3x3-Feld ausfüllen und immer das nächste Feld auswählen, das Zeilen oder Spalten mit einem Feld teilt, in dem Sie sich befinden Haben Sie bereits ausgefüllt, erhalten Sie ein Muster wie das folgende für die Anzahl der Auswahlmöglichkeiten pro Schritt (Füllen Sie zuerst das obere mittlere Feld, dann das obere rechte Feld usw.).

In jedem 3x3-Feld nach dem ersten werden drei der verbleibenden sechs Ziffern in einer einzelnen Zeile lokalisiert, sobald Sie eine Zeile oder Spalte des Felds ausgefüllt haben. Wählen Sie zuerst ihre Positionen aus und füllen Sie dann die verbleibenden drei Zellen aus. (Die tatsächliche Reihenfolge der auszufüllenden Zellen hängt davon ab, was Sie bereits wissen. Die Anzahl der Auswahlmöglichkeiten ist jedoch nie größer als die von mir angegebene.)

Nachdem Sie diese Felder ausgefüllt haben, werden alle Sterne bestimmt.

* * * 9 8 7 6 5 4
* * * 6 5 4 3 3 2
* * * 3 2 1 3 2 1

6 5 4 * * * 6 3 3
3 3 2 * * * 5 3 2
3 2 1 * * * 4 2 1

6 3 3 6 5 4 * * *
5 3 2 3 3 2 * * *
4 2 1 3 2 1 * * *

Wenn ich richtig gerechnet habe, ergibt das 87 Bit. Laut Peter Shors Kommentar sind im letzten 3x3-Block einige zusätzliche Einsparungen zu verzeichnen: Jeder Wert ist in einer von vier Zellen lokalisiert, und jede Zeile enthält mindestens eine Zelle mit nur vier möglichen Werten, also mit Sicherheit die Faktoren dafür Block sollte mit 4, nicht mit 6 beginnen, aber ich verstehe die verbleibenden Faktoren in Shors Antwort nicht.

Wenn Sie mit der Antwort von @ Peter fortfahren, finden Sie hier eine Liste der Worst-Case-Möglichkeiten für jede Zelle, während Sie sie von oben links ausfüllen

9   8   7       6   5   4       3   2   1
6   5   4       6   5   4       3   2   1
3   2   1       3   2   1       3   2   1

6   6   3       6   5   4       3   2   1
5   5   2       5   5   3       3   2   1
4   4   1       4   2   1       3   2   1

3   3   3       3   3   3       1   1   1
2   2   2       2   2   2       1   1   1
1   1   1       1   1   1       1   1   1

Dies ergibt 4.24559E + 29 Möglichkeiten oder 99 Bits

edit: habe vergessen, dass das letzte Quadrat vollständig von allen anderen bestimmt wird

Sie benötigen keine vollständige Nachschlagetabelle, um eine optimale Komprimierbarkeit zu erzielen. Ich glaube, dass moderne Computer, die eine sehr vernünftige Nachschlagetabelle verwenden, in der Lage sind, die Anzahl der beschränkten Sudokus zu zählen, die Sudokus sind, bei denen einige Ziffern bereits vorhanden sind. Hier erfahren Sie, wie Sie kodieren (Dekodierung ist ähnlich).

Legen Sie eine Reihenfolge der Quadrate fest. Angenommen, die Zahl auf dem ersten Quadrat ist . Setzen Sie N 1 als Anzahl der Sudokus, deren erstes Quadrat kleiner als d 1 ist . Sei nun d 2 die Nummer des zweiten Quadrats. Setzen Sie N 2 als die Anzahl der Sudokus, deren erstes Quadrat d 1 und deren zweites Quadrat kleiner als d 2 ist . Und so weiter. Die codierte Zahl ist N = ∑ i N i .$d_1$$N_1$$d_1$$d_2$$N_2$$d_1$$d_2$$N = \sum_i N_i$

Diese Codierungsmethode ist in der Literatur als Binomialcodierung bekannt . Sie sollten es Ihnen ermöglichen, den Index eines gegebenen Sudoku effektiv (im realen Sinne) zu berechnen und umgekehrt. Sie benötigen dann , wie oben erwähnt, nur Bits (dies bedeutet, dass Sie mehrere davon mit dieser durchschnittlichen Anzahl von Bits codieren können).$72.4$

Bearbeiten: Die Wikipedia-Seite über die Mathematik von Sudoku hilft uns, das Bild zu klären. Hilfreich ist auch eine von Ed Russell zusammengestellte Tabelle .

Es stellt sich heraus, dass, wenn Sie nur die obersten drei Zeilen berücksichtigen, im Wesentlichen nur 44 verschiedene Konfigurationen zu berücksichtigen sind. In der Tabelle finden Sie die Gesamtzahl der Konfigurationen, die den jeweiligen Konfigurationen entsprechen (vorausgesetzt, die oberste Zeile ist 123456789), sowie die Gesamtzahl der Abschlüsse für jede Konfiguration. Bei einem Sudoku berechnen wir die Ordnungszahl wie folgt:

1. Normalisieren Sie die Konfiguration so, dass die oberste Zeile 123456789 lautet.
2. Finden Sie heraus, zu welcher der 44 verschiedenen Konfigurationen sie gehört. Der Wikipedia-Artikel gibt dafür einen Algorithmus an. In der Tabelle sind die Anzahl der Äquivalenzklassen für jede Konfiguration sowie die Anzahl der Abschlüsse aufgeführt.
3. Bestimmen Sie die Ordnungszahl der Konfiguration der oberen drei Zeilen innerhalb der Äquivalenzklasse. Dies kann auf zwei Arten geschehen: entweder durch Verwendung einer Liste aller Äquivalenzklassen (es gibt insgesamt 36288 in allen Äquivalenzklassen) oder durch Auflisten aller Äquivalenzklassen.
4. Normalisieren Sie die verbleibenden Zeilen, indem Sie die Zeilen 4-6 und 7-9 nach ihrer ersten Spalte sortieren und anschließend diese beiden Zeilenblöcke auf beliebige Weise sortieren. Dies reduziert die Anzahl der Abschlüsse um den Faktor 72.
5. Zählen Sie alle Vervollständigungen mit derselben ersten Spalte auf. Es gibt ungefähr $2^{20}$ von ihnen für jede Äquivalenzklasse, so dass das nicht zu lange dauern sollte. Auch hier sind einige Kompromisse möglich.
6. Sei die Äquivalenzklasse, j die Ordnungszahl der Konfiguration der oberen drei Zeilen innerhalb der Äquivalenzklasse, k die Ordnungszahl der Vervollständigung. Es gibt zwei Arrays C i , D i (die aus Ed Russells Tabelle berechnet werden können), so dass C i + j D i + k die Ordnungszahl des Soduko bis zur 9 ist ! ⋅ 72 Symmetrien berücksichtigt. Daraus können Sie die tatsächliche Ordnungszahl berechnen.$i$$j$$k$$C_i,D_i$$C_i + jD_i + k$$9! \cdot 72$

Dieser Vorgang ist reversibel und generiert ein Sudoku aus einer Ordnungszahl. Beachten Sie, dass die Sudoku-Aufzählung auf einige Minuten (im Jahr 2006; siehe Diskussionsseite des Wikipedia-Artikels) oder weniger reduziert wurde. Daher erwarte ich, dass dieser Ansatz auf einem modernen Computer sehr praktisch ist und einige Sekunden oder weniger dauert.

Hier ist ein Algorithmus, von dem ich vermute, dass er eine ziemlich gute Kodierung liefert. Sie haben das fertige Sudoku, das Sie komprimieren möchten, und nehmen an, Sie haben bereits einige Zellen davon codiert. Es gibt also ein partielles Sudoku (nicht unbedingt mit einer eindeutigen Lösung), in dem einige Zellen ausgefüllt sind.

Verwenden Sie einen festen Algorithmus, um zu zählen, wie viele Zahlen in jede leere Zelle eingefügt werden können. Suchen Sie die lexikografisch erste Zelle, in die die kleinste Anzahl verschiedener Zahlen eingefügt werden kann, und kodieren Sie, welche dieser Zahlen darin enthalten ist. Wenn eine Zelle also nur eine 3, 7 oder 9 enthalten kann, wird die 3 mit "0" kodiert ", die 7 von" 1 "und die 9 von" 2 "). Codieren Sie die resultierende Sequenz mit einer arithmetischen Codierung (die die Anzahl der möglichen Zahlen berücksichtigt, die eine Zelle enthalten kann).

Ich weiß nicht, wie lang die resultierende Binärsequenz sein wird, aber ich vermute, dass sie ziemlich kurz ist, besonders wenn Ihr Algorithmus zum Zählen, wie viele Zahlen in eine Zelle gesetzt werden können, einigermaßen ausgefeilt ist.

Wenn Sie einen guten Algorithmus hätten, mit dem die Wahrscheinlichkeit geschätzt wird, dass jede Zelle eine bestimmte Zahl enthält, könnten Sie noch bessere Ergebnisse erzielen.

Kommentare und Kritik sind willkommen

$69.96$$171.72$

1.) Das Speichern des Puzzles impliziert das Speichern der Lösung (Information theoretisch).

$t(\alpha)\alpha^{2}$$t(\alpha)$$\alpha$$t(3) ~= 2.44444$$3$

$P$$\alpha^{4}$$t(\alpha)\alpha^{2}$ ungleich Null Einträgen.

$M$$\beta \times \alpha^{4}$$\beta \ge 2t(\alpha)\alpha^{2}$$2t(\alpha)\alpha^{2}$$\{0,\pm 1\}$$\beta = kt(\alpha)\alpha^{2}$$k$

$V = MP$$\beta$$|\alpha^{2}|$$M$$\{0,\pm 1\}$ .

$V$$\beta\log{\alpha^{2}} = 2kt(\alpha)\alpha^{2}\log{\alpha}$ bits.

In your case, $\alpha = 3$ and $t(\alpha) ~= 3$ and $2kt(\alpha)\alpha^{2}\log{\alpha} = 69.96k$bits to $85.86k$ bits. $k=2$, the minumum required provides roughly $139.92$bits to $171.72bits$ roughly as a lower bound for the average case.

Note that I have hand-waived some assumptions such as sizes of entries of $MP$ and number of entries one has on average in the puzzle.

$A.)$Of course, it mightbe possible to reduce $k$ from $2$ since in sudoku the position of the sparse entries are not that mutually independent. Each entry on an average $t(\alpha)-1$ entries each in its row, column and sub-box. That is given, that some entries are present in a sub-box or column or row, one can find the odds of entries being present in the same row, column or sub-box.

$B.)$ Each row, column or sub-box is assumed to have on an average $t(\alpha)$ non-zero entries with no-repeating alphabet. This means some types of vectors with $t(\alpha)$ non-zero entries will never occur, thereby reducing the search space of solutions. This could also reduce $k$. For instance, fixing $t(\alpha)$ entries in a sub-box, a row and a column would reduce the search space from ${}^{\alpha^{4}}C_{t(\alpha)\alpha^{2}}$ to ${}^{\alpha^{4}-(3\alpha^{2} - 1)}C_{t(\alpha)\alpha^{2}-3t(\alpha)}$.

A comment: May be a multi-user arbitrarily correlated Slepian-Wolf model will help make the entries independent while still respecting the atmost $t(\alpha)\alpha^{2}$ non-zero entries criterion. However, if one could use it, one need not have gone through the compressed sensing route. So applicability of Slepian-Wolf might be hard.

$C.)$From an error correction analogy, an even significant reduction may be possible, since in higher dimensions, there could be gaps between the half-the-minimum-distance radii hamming balls around code points with a possibility to correct greater errors. This also should lead to reduction of $k$.

$D.)$ $V$ itself can be entropy compressed. If the entries of $V$ are quite similar in sizes, then can we assume that the difference between any two of the entries is atmost $O(\sqrt(V_{max})) = O(\sqrt{|\alpha^{2}|})$? Then if encoding the differences between the entries suffices, this itself will remove the factor $2$ in $\beta\log{\alpha^{2}} = 2kt(\alpha)\alpha^{2}\log{\alpha}$.

It would be interesting to see if $2k$ can be made equal or less than $2$ using $A.)$, $B.)$, $C.)$ and $D.)$. This would be better than $89$ bits (which is the best so far in other answers) and for the best case better than the absolute minimum for all puzzles which is around $73$bits.

This is to report an implementation of completed-sudoku compact encoding (similar to suggestion by Zurui Wang 9/14/11).

The input is the top row and 1st 3 digits of the 2nd row. These are reduced to 1-9! and 1-120 and combined to <= 4.4x10^7. These are used as givens to count lexicographically all the partial sukokus of 30 digits up to the matching sequence. Then the final count up to the entire 81 digits is done the same way. These 3 sequences are stored as 32-bit integers of max 26 bits, so can be compressed further. The entire process takes about 3 minutes, with the 1st 30 digits taking most of the time. The decoding is similar--except matching counts instead of sudokus.

Coming soon--Revision includes 1st 3 digits of 2nd row in enumeration of 30 digit completions (2nd 32-bit code), comparisons with Jarvis enumeration (Jscott, 3/1615)

I would go with the following simple analysis:

Each value could be stored in 4 bits (ranges from 1-9, these three bits even allow for 0-16)

If we considered to store the WHOLE solution (not optimal), having $9 \times 9 = 81$ values. 3 bits each = 243 bits.

However, as the rules that the solved sudoku has to follow, storing every bit is in fact redundant. However, since the order is important, you need to store the first 8 values in each row (thus determining the 9th value), for 8 rows (thus determining the last row). This reduces the sudoku to $8 \times 8$ for 3 bits, 192 bits (24 bytes).

I guess I could reduce it to:

$b = \lceil \log_2(v) \rceil (n-1)$

where

$v$ = range of values (I've seen 0-5 sudokus a lot)

$n$ = number of rows / columns

Edit: Neo Style: I know Latex.

That number is different for each Sudoku. One of the rules for Sudoku is that it has exactly one solution.

So if you look at an example, that's the minimum amount of data that you must store.

If you work from the opposite side, you can remove digit by digit and run a solver on the result to see if it still has exactly one solution. If so, you can delete another digit. If not, you must restore this digit and try another. If you can't, you have found a minimum.

Since most puzzles start mostly empty, a run length encoding will probably yield good results.