sudoku-solver/board.py

"""This module contains the Board class.

It is used to represent different elements for the whole board.
"""

from square import Square


class Board:
    """The Board class contains different elements of the board."""

    def __init__(self, string):
        self.lines = [""] * 9
        i = 0
        line = 0
        while line < 9:
            if string[i] == '\n':
                line += 1
            else:
                self.lines[line] += string[i]
            i += 1

        self.columns = [""] * 9
        for col in range(9):
            for line in self.lines:
                self.columns[col] += line[col]

        self.grids = self.__compute_grid_values()
        self.squares = []

        self.__assert_lines_and_columns_have_same_values()

    def __str__(self):
        output = ""
        for line in self.lines:
            for item in line:
                if isinstance(item, set):
                    if len(item) == 1:
                        output += str(item)[1:-1]
                    else:
                        output += '.'
                elif isinstance(item, Square):
                    if len(item.values) == 1:
                        output += str(item.values)[2:-2]
                    else:
                        output += '.'
                else:
                    output += item
                output += ' '
            output += '\n'

        return output

    def __assert_lines_and_columns_have_same_values(self):
        differences = []
        for lin in range(len(self.lines)):
            for col in range(len(self.columns)):
                if isinstance(self.lines[lin][col], Square):
                    line_values = self.lines[lin][col].values
                    column_values = self.columns[col][lin].values
                else:
                    line_values = self.lines[lin][col]
                    column_values = self.columns[col][lin]

                if line_values != column_values:
                    differences.append('X')

        assert len(differences) == 0

    def __compute_grid_values(self):
        grids = [""] * 9
        for lin, line in enumerate(self.lines):
            for col in range(9):
                if line[col] != '.':
                    if lin // 3 == 0 and col // 3 == 0:
                        grids[0] += line[col]
                    elif lin // 3 == 0 and col // 3 == 1:
                        grids[1] += line[col]
                    elif lin // 3 == 0 and col // 3 == 2:
                        grids[2] += line[col]
                    elif lin // 3 == 1 and col // 3 == 0:
                        grids[3] += line[col]
                    elif lin // 3 == 1 and col // 3 == 1:
                        grids[4] += line[col]
                    elif lin // 3 == 1 and col // 3 == 2:
                        grids[5] += line[col]
                    elif lin // 3 == 2 and col // 3 == 0:
                        grids[6] += line[col]
                    elif lin // 3 == 2 and col // 3 == 1:
                        grids[7] += line[col]
                    elif lin // 3 == 2 and col // 3 == 2:
                        grids[8] += line[col]

        return [set(values) for values in grids]

    def __compute_possible_values_from_lines(self):
        """Compute possible values for each number in a line.

        Go through each line and add possible values to each square that hasn't
        been found yet. The values are computed based on the fact that they
        aren't already present in that same line.
        """

        for lin, line in enumerate(self.lines):
            self.lines[lin] = list(line)
            for column in range(9):
                if line[column] == '.':
                    self.lines[lin][column] = {
                        str(number) for number in range(1, 10)
                        if str(number) not in line
                    }
                else:
                    self.lines[lin][column] = {line[column]}

    def __compute_possible_values_from_columns(self):
        """Compute possible values for each number in a column.

        Go through each column and add possible values to each square that
        hasn't been found yet. The values are computed based on the fact that
        they aren't already present in that same column.
        """

        for col, column in enumerate(self.columns):
            self.columns[col] = list(column)
            for line in range(9):
                if column[line] == '.':
                    self.columns[col][line] = {
                        str(number) for number in range(1, 10)
                        if str(number) not in column
                    }
                else:
                    self.columns[col][line] = {column[line]}

    def compute_possible_values(self):
        """Compute possible values for each square in the board."""

        self.__compute_possible_values_from_lines()
        self.__compute_possible_values_from_columns()

    def create_squares(self):
        """Make each square of the board a Square object."""

        self.squares = []

        if isinstance(self.lines[0][0], set):
            print("SQUARES CREATED")
            for lin, line in enumerate(self.lines):
                for col in range(len(self.columns)):
                    square = Square(lin, col, line[col])
                    self.lines[lin][col] = square
                    self.columns[col][lin] = square
                    self.squares.append(square)

        self.__assert_lines_and_columns_have_same_values()

    def intersect_lines_and_columns(self):
        """Remove impossible values from possibilities in lines and columns.

        Go through each line and for each square intersect the set with the set
        in the same square in self.columns.
        Go through each column and for each square intersect the set with the
        set in the same square in self.lines.

        Note: you need to run compute_possible_values first.
        """

        for lin, line in enumerate(self.lines):
            for col, column in enumerate(self.columns):
                if isinstance(self.lines[lin][col], Square):
                    self.lines[lin][col].values = line[col].values.intersection(column[lin].values)
                    self.columns[col][lin].values = column[lin].values.intersection(line[col].values)
                else:
                    self.lines[lin][col] = line[col].intersection(column[lin])
                    self.columns[col][lin] = column[lin].intersection(line[col])

        self.__assert_lines_and_columns_have_same_values()

    def discard_with_grids(self):
        """Remove impossible values in squares, by discarding from grids."""

        for square in self.squares:
            # print(square.values)
            # print(self.grids[square.grid_id])
            if len(square.values) > 1:
                for value in self.grids[square.grid_id]:
                    if value in square.values:
                        square.values.discard(value)
            # print(square.values)
            # print()