Sudoku-Checker in Python

Denken Sie daran, Sie sind nicht der Suche nach Duplikaten -- nur ungleich null Duplikate. Fazit ein set funktioniert. Sie können auch überprüfen Sie die Rechtmäßigkeit der Zeile/Spalte in der gleichen Zeit:

def sudoku_ok(line):
    return (len(line) == 9 and sum(line) == sum(set(line)))

def check_sudoku(grid):
    bad_rows = [row for row in grid if not sudoku_ok(row)]
    grid = list(zip(*grid))
    bad_cols = [col for col in grid if not sudoku_ok(col)]
    squares = []
    for i in range(9, step=3):
        for j in range(9, step=3):
          square = list(itertools.chain(row[j:j+3] for row in grid[i:i+3]))
          squares.append(square)
    bad_squares = [square for square in squares if not sudoku_ok(square)]
    return not (bad_rows or bad_cols or bad_squares)

InformationsquelleAutor llb

Definieren Sie eine Funktion, um zu überprüfen, dass keine Duplikate vorhanden sind, dann können Sie es verwenden, um zu überprüfen, Zeilen, Spalten und 3x3-raster. Reduzieren Sie die verschachtelte Blöcke durch Rücksendung früh, wenn eine Bedingung nicht erfüllt, zum Beispiel die Anzahl der Zeilen, die größer sind als 9. Und nur true zurückgeben, die ganz am Ende der Funktion, wenn keine der Prüfungen scheitern.

from collections import Counter

def check_dups(l):
    counts = Counter()
    for cell in l:
        if cell != 0: counts[cell] += 1
        if cell > 9 or counts[cell] > 1: return False
    return True

def check_sudoku(grid):
    if len(grid) != 9: return False
    if sum(len(row) == 9 for row in grid) != 9: return False
    for row in grid:
        if not check_dups(row): return False
    return True

InformationsquelleAutor perreal

Nur überprüfen Sie nach jeder Zeile/Spalte mit:

sorted(row) == range(1,10)

oder für python 3

sorted(row) == list(range(1,10))

Stell ich mir die Laufzeit wird dominiert durch das erstellen einer neuen Liste (ob Sie das Histogramm-Ansatz oder die Sortier-Ansatz), damit der zusätzliche Faktor von log(n) sollte nicht spürbar sein

Um zu prüfen, jede Zeile,Spalte und subsquare, ich schlage vor, dass extractor Methoden, die die N-te Zeile, Spalte und subsquare aus der matrix (dh nicht versuchen, und setzen Sie alles in einer Methode).

So zum Beispiel:

getSubSquare(m, i):
    subrow = (i // 3) * 3
    subcol = (i % 3) * 3
    v = [0] * 9
    for j in range(9):
        subrj = j // 3
        subcj = j % 3
        v[j] = m[subrow + subrj][subcol + subcj]
    return v

getRow(m,i):
   return m[i]

getCol(m,i):
   return [m[j][i] for j in range(9)]

InformationsquelleAutor dspyz

def check_sudoku(grid):
if len(grid) == 9:
    numsinrow = 0
    for i in range(9):
        if len(grid[i]) == 9:
            numsinrow += 1
    if numsinrow == 9:
        if checkrow(grid):
            if checkcol(grid):
                return True
            else:
                return False
        else:
            return False
    else:
        return False
else:
    return False

def checkrow(grid):
    for i in range(9):
        rowoccurence = [0,0,0,0,0,0,0,0,0,0]
        for j in range(9):
            rowoccurence[grid[i][j]] += 1
        temprow = rowoccurence[1:10]
        for q in range(9):
            if temprow[q] == 1 or temprow[q] == 0:
                continue
            else:
                return False
    return True

def checkcol(grid):
    for num in range(9):
        coloccurence = [0,0,0,0,0,0,0,0,0,0]
        for i in range(9):
            coloccurence[grid[i][num]] += 1
        tempcol = coloccurence[1:10]
        for q in range(9):
            if tempcol[q] == 1 or tempcol[q] == 0:
                continue
            else:
                return False
    return True

Ok Jungs, ich bin zurück mit einer Funktion prüfen, die Zeilen, die funktioniert. Ich danke Euch so sehr für all die Hilfe. Ich bin sozusagen ein noob in diesem, so dass ich nicht verstehen, einige Antworten, aber ich merkte, dass ich true zurückgeben viel zu früh. Ich erkannte auch, dass, wenn es mehrere Nullen in einer Zeile, dann ein paar zahlen würden nicht kommen in der rowoccurence/temp-Liste. Dies ist der Grund, warum ich hatte zu prüfen, für die sowohl 1 und 0 in der rowoccurence/temp-Liste. Ich habe auch geschrieben eine ähnliche Funktion zum überprüfen der Spalten. Nochmals vielen Dank!

InformationsquelleAutor quagpwn

Schrieb eine einfache Klasse für ein Modell eines (ausgefüllten) Sudoku-Brett. Nichts schwierig, aber eine einfache Lösung für ein 9x9-Brett.

class SudokuBoard(object):

    DIGITS = set(range(1, 10))

    def __init__(self, values):
        self.values = values

    def row(self, n):
        return self.values[n]

    def rows(self):
        return self.values

    def cols(self):
        return [self.col(i) for i in xrange(9)]

    def col(self, n):
        return [self.values[i][n] for i in xrange(len(self.values))]

    def groups(self):
        return [self.group(i) for i in xrange(9)]

    def group(self, n):
        start_r = (n / 3) * 3
        start_c = n * 3   % 9
        values = []
        for row in xrange(start_r, start_r + 3):
            for col in xrange(start_c, start_c + 3):
                values.append(self.values[row][col])
        return values

    def is_correct(self):
        for row in self.rows():
            if self.DIGITS - set(row):
                return False
        for col in self.cols():
            if self.DIGITS - set(col):
                return False
        for group in self.groups():
            if self.DIGITS - set(group):
                return False
        return True

InformationsquelleAutor Adam Donahue