Mathematik mit Python lösen (unvollständig)
Vor kurzem bin ich süchtig danach, Supreme Germany in einem Smartphone-Spiel zu lösen. Suchen Sie beim Lösen mit Papier und Stift die Zellen, die möglicherweise numerische Werte enthalten, und wenden Sie die numerischen Werte auf diese an. Wenn Sie mit einem Gerät wie einem Smartphone lösen und alle Quadrate allen Quadraten zugewiesen haben, suchen Sie nach den Quadraten, die wahrscheinlich nicht denselben numerischen Wert enthalten, aus den ermittelten Quadraten und löschen Sie die numerischen Werte. Es ist schneller, durch "Subtraktion" zu denken.
Ich löse es immer mit dieser Methode, aber ich habe ein Programm geschrieben und versucht zu prüfen, ob diese Methode jedes Mal ein Problem algorithmisch (?) Lösen kann. Aus der Schlussfolgerung heraus gab es einige Probleme, die nicht gelöst werden konnten. Wenn Sie also ein Programm erstellen möchten, das unbedingt gelöst werden kann, empfehlen wir Ihnen, eine Round-Robin-Methode in Betracht zu ziehen, bei der Sie in der Reihenfolge von einem Ende aus ersetzen. (Siehe unten)
Wie zu lösen (Bild)
Zuallererst, wenn es ein solches Problem gab
(1) Ersetzen Sie alle Zellen, für die die Nummern nicht ermittelt wurden, einmal durch alle Zahlen.
(2) Achten Sie auf jedes der ermittelten Elemente und löschen Sie die numerischen Werte vertikal, horizontal und innerhalb des 3x3-Quadrats, in dem die numerischen Werte vorhanden sind.
(Diese Zahl ist nach dem Betrieb mit "1" in der Mitte links. Wiederholen Sie diesen Vorgang für alle ermittelten Werte.)
③ Achten Sie diesmal auf Vertikal, Horizontal und 3x3 und geben Sie den Wert ein, der nur in diesem Element als Entscheidungswert eingegeben werden kann.
(Im Fall dieser Figur gibt es oben links nur eine "1" 3x3, daher wird hier "1" bestimmt.)
④ Wiederholen Sie diese Vorgänge.
Implementieren Sie dies programmgesteuert.
Code
sudoku_solver.py
import numpy as np
import copy
xx = [1, 2, 3, 4, 5, 6, 7, 8, 9]
x1 = [1]
x2 = [2]
x3 = [3]
x4 = [4]
x5 = [5]
x6 = [6]
x7 = [7]
x8 = [8]
x9 = [9]
lists = [
[copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(x4), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(xx)],
[copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(x5), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(xx)],
[copy.deepcopy(xx), copy.deepcopy(x3), copy.deepcopy(x6), copy.deepcopy(x8), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(x7), copy.deepcopy(x2)],
[copy.deepcopy(xx), copy.deepcopy(x8), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(x6), copy.deepcopy(x5), copy.deepcopy(xx), copy.deepcopy(xx)],
[copy.deepcopy(x1), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(x5), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(x9), copy.deepcopy(xx)],
[copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(x2), copy.deepcopy(xx), copy.deepcopy(x7)],
[copy.deepcopy(xx), copy.deepcopy(x1), copy.deepcopy(xx), copy.deepcopy(x2), copy.deepcopy(xx), copy.deepcopy(x8), copy.deepcopy(x4), copy.deepcopy(x3), copy.deepcopy(x6)],
[copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(x8), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(x4), copy.deepcopy(x7), copy.deepcopy(xx), copy.deepcopy(x9)],
[copy.deepcopy(xx), copy.deepcopy(x6), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(x1), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(xx), copy.deepcopy(x5)],
]
cells = np.array(lists)
flags = np.zeros((9, 9))
grid = [(0, 3), (3, 6), (6, 9)]
while np.any(flags==0):
for i, ii in enumerate(cells):
for j, jj in enumerate(ii):
if len(jj) == 1 and flags[i, j] == False:
num = jj[0]
flags[i, j] = True
#Suchen Sie vertikal, horizontal und in die Richtung und löschen Sie dieselbe Nummer
for kk in cells[i]:
if num in kk and len(kk) != 1:
kk.remove(num)
for kk in cells[:, j]:
if num in kk and len(kk) != 1:
kk.remove(num)
#Löschen Sie dieselbe Nummer in 3x3
if i < 3:
l = 0
elif i >= 3 and i < 6:
l = 3
elif i >= 6 and i < 9:
l = 6
if j < 3:
d = 0
elif j >= 3 and j < 6:
d = 3
elif j >= 6 and j < 9:
d = 6
for ll in cells[l:l+3, d:d+3]:
for mm in ll:
if num in mm and len(mm) != 1:
mm.remove(num)
for ii in range(1, 10):
#Suchen Sie vertikal, horizontal und in die Richtung und entscheiden Sie, ob nur eine Nummer eingegeben wird
for jj in range(0, 9):
counter1 = 0
counter2 = 0
marker1 = 0
marker2 = 0
for kk in range(0, 9):
if ii in cells[jj, kk]:
counter1 += 1
marker1 = kk
if ii in cells[kk, jj]:
counter2 += 1
marker2 = kk
if counter1 == 1:
cells[jj, marker1].clear()
cells[jj, marker1].append(ii)
if counter2 == 1:
cells[marker2, jj].clear()
cells[marker2, jj].append(ii)
#Suchen Sie innerhalb von 3x3 und entscheiden Sie, ob nur eine Nummer eingegeben wird
for jj in grid:
for kk in grid:
counter3 = 0
marker3 = 0
marker4 = 0
for mm, ll in enumerate(cells[jj[0]:jj[1], kk[0]:kk[1]]):
for oo, nn in enumerate(ll):
if ii in nn:
counter3 += 1
marker3 = mm
marker4 = oo
if counter3 == 1:
cells[jj[0]+marker3, kk[0]+marker4].clear()
cells[jj[0]+marker3, kk[0]+marker4].append(ii)
#Erstellen eines Arrays zum Drucken
num_list = []
for ii in cells:
_num_list = []
for jj in ii:
if len(jj) == 1:
_num_list.append(jj[0])
else:
_num_list.append(0)
num_list.append(_num_list)
print("---------------------------")
for ii in num_list:
print(ii)
print("---------------------------")
Einer meiner Zwecke war es, Numpy zu üben, also benutze ich es vorerst. Für ein dreidimensionales Array mit einer Liste mit 1 bis 9 in 9x9, ob der numerische Wert der Zelle bestimmt wurde (ob die Länge des dreidimensionalen Arrays 1 ist) und führen Sie die Operation von ② aus Das Problem wird beim Verwalten mit einem zweidimensionalen 9x9-Array gelöst, das verwaltet, ob es mit True-False abgeschlossen wurde oder nicht.
Ausführungsergebnis
Hier ist das Ergebnis der Ausführung.
---------------------------
[2, 7, 1, 6, 4, 3, 9, 5, 8]
[8, 9, 5, 1, 7, 2, 3, 6, 4]
[4, 3, 6, 8, 9, 5, 1, 7, 2]
[7, 8, 3, 9, 2, 6, 5, 4, 1]
[1, 4, 2, 5, 8, 7, 6, 9, 3]
[6, 5, 9, 4, 3, 1, 2, 8, 7]
[9, 1, 7, 2, 5, 8, 4, 3, 6]
[5, 2, 8, 3, 6, 4, 7, 1, 9]
[3, 6, 4, 7, 1, 9, 8, 2, 5]
---------------------------
Schließlich
Es scheint, dass es Probleme gibt, die mit dieser Logik allein nicht gelöst werden können, und während der Versuch, solche Probleme zu lösen, dreht sich alles weiter. Ich habe es diesmal durch Nachforschungen herausgefunden, aber es scheint, dass es in Sugoku verschiedene Lösungen gibt, und es scheint, dass mit dieser Lösung etwas nicht ausreicht (ich weiß nicht, was es ist). Dieses Mal war es nicht das Ziel, alle Probleme in Deutschland zu lösen, also habe ich es vorerst nur überprüft. Wenn Sie die Fortsetzung beenden möchten, denke ich, dass das Folgende hilfreich sein wird. Vorerst denke ich, dass es schneller fertig sein wird als das Round-Robin.
So lösen Sie Nampure / Advanced
Ich möchte nur jedes Problem lösen! Wie eingangs erwähnt, wird empfohlen, die folgende Round-Robin-Methode zu verwenden.
Auch dieses Mal habe ich es nur normal gelöst, aber das allein ist nicht interessant, also habe ich versucht, das Problem anhand der Bilder und Fotos zu erkennen und es zu lösen. Nächstes Mal werde ich über diesen Bereich schreiben.
Recommended Posts