Relictum solver

# -*- coding: utf-8 -*-
"""
Created on Thu Jan 18 00:56:57 2018

@author: Mauro
"""

class Mat:

    def __init__(self):
        self.size = 5
        self.values = []

        for x in range(self.size):
            for y in range(self.size):
                self.values.append(0)

        self.setxy(0, 0, 1)
        self.setxy(2, 0, 2)
        self.setxy(4, 0, 3)
        self.setxy(1, 4, 3)
        self.setxy(3, 4, 4)

        shape0 = [(0, 0), (1, 0), (2, 0), (0, 1), (1, 1)]
        shape1 = [(3, 0), (4, 0), (3, 1), (4, 1), (4, 2)]
        shape2 = [(3, 3), (4, 3), (2, 4), (3, 4), (4, 4)]
        shape3 = [(0, 2), (0, 3), (1, 3), (0, 4), (1, 4)]
        shape4 = [(2, 1), (1, 2), (2, 2), (3, 2), (2, 3)]

        self.shapes = []
        self.shapes.append(shape0)
        self.shapes.append(shape1)
        self.shapes.append(shape2)
        self.shapes.append(shape3)
        self.shapes.append(shape4)

    def get_shape_values(self, shapen):
        res = []
        for e in self.shapes[shapen]:
            res.append(self.getxy(e[0], e[1]))
        return res

    def get_shape_values_xy(self, x, y):
        for i, shape in enumerate(self.shapes):
            if (x, y) in shape:
                return self.get_shape_values(i)

    def get_line_values_xy(self, ix, y):
        ret = []
        for x in range(self.size):
            ret.append(self.getxy(x, y))
        return ret

    def get_column_values_xy(self, x, iy):
        ret = []
        for y in range(self.size):
            ret.append(self.getxy(x, y))
        return ret

    def getxy(self, x, y):
        return self.values[x * self.size + y]

    def setxy(self, x, y, v):
        self.values[x * self.size + y] = v


    def __str__(self):
        s = ''
        for x in range(self.size):
            for y in range(self.size):
                s+= str(self.getxy(y, x)) + ' '
            s += '\n'
        return s


m = Mat()

print(m)

m.setxy(3, 1, 2)
m.setxy(4, 1, 1)
#m.setxy(1, 1, 1)
m.setxy(1, 0, 4)
m.setxy(1, 1, 5)
m.setxy(0, 1, 3)
m.setxy(2, 1, 4)
m.setxy(4, 4, 5)
m.setxy(0, 4, 2)
m.setxy(1, 3, 1)
m.setxy(1, 2, 2)
m.setxy(2, 4, 1)
m.setxy(3, 0, 5)
m.setxy(3, 3, 3)
m.setxy(2, 3, 5)
m.setxy(0, 3, 4)
m.setxy(0, 2, 5)
m.setxy(2, 2, 3)
m.setxy(3, 2, 1)
m.setxy(4, 2, 4)





def solve_step(mat):
    candidates = []
    for x in range(mat.size):
        for y in range(mat.size):
            # skip if is already full
            if mat.getxy(x,y) != 0:
                pass
                #print('position:', x, y, 'already occupied:', mat.getxy(x,y))
            else:
                #print('position free')
                n = []
                n += [v for v in mat.get_shape_values_xy(x,y) if v != 0 and v not in n]
                n += [v for v in mat.get_line_values_xy(x,y) if v != 0 and v not in n]
                n += [v for v in mat.get_column_values_xy(x,y) if v != 0 and v not in n]

                if len(n) == 4:
                    #print("we have a candidate")
                    candidates.append((x, y, list(set([1, 2, 3, 4, 5]) -  set(n))[0]))

    return candidates

candidates = [0]
while len(candidates) == 1:
    candidates = solve_step(m)
    print(candidates)
    c = candidates[0]
    m.setxy(c[0], c[1], c[2])
    print(m)