kenken/main.py

import itertools
from copy import deepcopy
from itertools import combinations, combinations_with_replacement

OP_PLUS = "PLUS"
OP_MINUS = "MINUS"
OP_MULTIPLY = "MULTIPLY"
OP_DIVIDE = "DIVIDE"
OP_NONE = "NONE"


def lambda_mul(x):
    rv = 1
    for v in x:
        rv *= v
    return rv


OP_LAMBDAS = {
    OP_PLUS: sum,
    OP_MINUS: lambda x: abs(x[0] - x[1]),
    OP_MULTIPLY: lambda_mul,
    OP_DIVIDE: lambda x: x[0] / x[1] if x[0] % x[1] == 0 else x[1] / x[0],
    OP_NONE: lambda x: x[0],
}

BOX_H_LABELS = 'ABCDEF'
BOX_V_LABELS = '654321'


def translate_box_to_rc(box):
    return BOX_V_LABELS.index(box[1]), BOX_H_LABELS.index(box[0])


def has_line_integrity(line):
    existing_values = set()
    for value in line:
        if value in existing_values:
            return False
        if value != 0:
            existing_values.add(value)
    return True


def fill_grid(grid, solution):
    box_values = []
    for box_value in solution:
        box_values.append(box_value)
    for box, value in box_values:
        br, bc = translate_box_to_rc(box)
        grid[br][bc] = value
    return grid


def check_grid(grid):
    for row in grid:
        if not has_line_integrity(row):
            return False
    for col_id in range(len(grid)):
        col = [grid[r][col_id] for r in range(len(grid))]
        if not has_line_integrity(col):
            return False
    return True


def init_grid(grid_size):
    return [[0] * grid_size for _ in range(grid_size)]


class Block(object):
    def __init__(self, boxes, operation, result):
        self.boxes = boxes
        self.operation = operation
        self.result = result

        self.solutions = set()

        self.verify()

    def verify(self):
        """
        Verifies that the box location are valid in the range A-F and 1-6
        Operations are in +-*/ or None.
        Where -/ have exactly 2, None has exactly 1.
        """
        assert self.operation in OP_LAMBDAS
        if self.operation in [OP_NONE]:
            assert len(self.boxes) == 1
        elif self.operation in [OP_MINUS, OP_DIVIDE]:
            assert len(self.boxes) == 2
        else:
            assert len(self.boxes) > 1
        for box in self.boxes:
            assert len(box) == 2
            assert box[0] in BOX_H_LABELS
            assert box[1] in BOX_V_LABELS

    def all_boxes_in_one_row_or_column(self):
        """Returns true if all of the boxes are in the same row OR the same column"""
        is_same_column, is_same_row = True, True
        for box in self.boxes[1:]:
            if self.boxes[0][0] != box[0]:
                is_same_column = False
            if self.boxes[0][1] != box[1]:
                is_same_row = False
        return is_same_row or is_same_column

    def generate_combinations(self, k, n):
        """Generates k|n combinations for 2 boxes or if they are in the same row OR column.
        Generates k|n combinations with replacements for other cases."""
        assert 1 <= k < n
        # Exploit the structure of the problem
        # For block of size 2, we don't need comb with replacement as they will
        # neccesarily be in different columns/rows
        if k == 2:
            return list(combinations(range(1, n + 1), k))
        # for 3 and more we don't need if all of the boxes are on the
        # same row or same column
        elif k > 2:
            if self.all_boxes_in_one_row_or_column():
                return list(combinations(range(1, n + 1), k))
        return list(combinations_with_replacement(range(1, n + 1), k))

    def generate_hypotheses(self, grid_size):
        """Generates hypothesis for this block based on the operation and result."""
        rv = []
        op = OP_LAMBDAS[self.operation]
        hypotheses = self.generate_combinations(k=len(self.boxes), n=grid_size)
        for hypothesis in hypotheses:
            if op(hypothesis) == self.result:
                rv.append(hypothesis)
        return rv

    def generate_solutions(self, grid_size):
        """Generates possible solutions for the block, including the limiting row/column requirement."""
        self.generate_hypotheses(grid_size)
        for hyp in self.generate_hypotheses(grid_size):
            for perm in itertools.permutations(hyp):
                sol = tuple(zip(self.boxes, perm))
                if check_grid(fill_grid(init_grid(grid_size), sol)):
                    self.solutions.add(sol)

    def __repr__(self):
        return 'Block {}'.format(self.boxes)


class Game(object):
    def __init__(self, grid_size, blocks):
        self.blocks = blocks
        self.grid_size = grid_size
        self.verify()

        for block in self.blocks:
            block.generate_solutions(self.grid_size)

    def verify(self):
        """Check that each block is found exactly once in the grid."""
        found = set()
        for block in self.blocks:
            for box in block.boxes:
                assert box not in found
                found.add(box)
        assert len(found) == self.grid_size ** 2

    def solve(self, grid, current_block_id=0):
        """
        Recursive solution - Start by filling up the first block.
        For each solution that passes the row/column requirement, check the recursive solution
        with the next block. Break when it's the last block and the row/col requirement is filled.
        """
        block = self.blocks[current_block_id]
        for solution in block.solutions:
            prev_grid = deepcopy(grid)
            grid = fill_grid(grid, solution)
            if not check_grid(grid):
                grid = prev_grid
            else:
                if current_block_id == len(self.blocks) - 1:
                    return grid
                sol = self.solve(deepcopy(grid), current_block_id + 1)
                if sol:
                    return sol


def main():
    game = Game(grid_size=6,
                blocks=[
                    Block(boxes=['A6', 'B6', 'C6', 'D6'], operation=OP_MULTIPLY, result=120),
                    Block(boxes=['E6', 'E5', 'E4', 'F4'], operation=OP_PLUS, result=17),
                    Block(boxes=['F6', 'F5'], operation=OP_PLUS, result=5),
                    Block(boxes=['A5', 'B5'], operation=OP_MINUS, result=1),
                    Block(boxes=['C5', 'C4'], operation=OP_DIVIDE, result=2),
                    Block(boxes=['D5', 'D4'], operation=OP_PLUS, result=3),
                    Block(boxes=['A4', 'A3'], operation=OP_PLUS, result=5),
                    Block(boxes=['B4', 'B3', 'C3'], operation=OP_MULTIPLY, result=30),
                    Block(boxes=['D3', 'D2', 'E2'], operation=OP_MULTIPLY, result=15),
                    Block(boxes=['B2', 'C2', 'C1'], operation=OP_MULTIPLY, result=10),
                    Block(boxes=['A2'], operation=OP_NONE, result=6),
                    Block(boxes=['A1', 'B1'], operation=OP_DIVIDE, result=3),
                    Block(boxes=['D1', 'E1'], operation=OP_MINUS, result=1),
                    Block(boxes=['F1', 'F2', 'F3', 'E3'], operation=OP_PLUS, result=16),
                ])
    grid = game.solve(grid=init_grid(game.grid_size))
    for line in grid:
        print(line)


if __name__ == '__main__':
    main()