def __init__(self, colors, neighbors): """Make a CSP for the problem of coloring a map with different colors for any two adjacent regions. Arguments are a list of colors, and a dict of {region: [neighbor,...]} entries. This dict may also be specified as a string of the form defined by parse_neighbors.""" def parse_neighbors(neighbors): """Convert a string of the form 'X: Y Z; Y: Z' into a dict mapping regions to neighbors. The syntax is a region name followed by a ':' followed by zero or more region names, followed by ';', repeated for each region name. If you say 'X: Y' you don't need 'Y: X'. """ dic = defaultdict(list) specs = [spec.split(':') for spec in neighbors.split(';')] for (A, Aneighbors) in specs: A = A.strip() for B in Aneighbors.split(): dic[A].append(B) dic[B].append(A) return dic if isinstance(neighbors, str): neighbors = parse_neighbors(neighbors) def different_values_constraint(A, a, B, b): """A constraint saying two neighboring variables must differ in value.""" return a != b CSP.__init__(self, list(neighbors.keys()), UniversalDict( colors), neighbors, different_values_constraint)
def __init__(self, grid): domains = {} for var in flatten(self.bgrid): domains[var] = ['V', 'R', 'A', '.'] CSP.__init__(self, None, domains, self.neighbors, self.pic_a_pix_constraint)
def __init__(self, n): """Initialize data structures for n Queens.""" CSP.__init__(self, range(n), UniversalDict(range(n)), UniversalDict(range(n)), queen_constraint) update(self, rows=[0] * n, ups=[0] * (2 * n - 1), downs=[0] * (2 * n - 1))
def __init__(self, n): """Initialize data structures for n Queens. As we are choosing only the y coordinate of every queen the domain and the neighbors are list(range(n)) for every column (alias variable) """ CSP.__init__(self, list(range(n)), UniversalDict(list(range(n))), UniversalDict(list(range(n))), queen_constraint)
def __init__(self, filename): """Create a Kenken puzzle by taking all the neccessary input from the specified text file""" ln = 0 # number of line-to-read with open(filename) as f: # take input from the text file for line in f: ln += 1 # the line that we are reading if ln == 1: print(line) self.n = int(line) else: a = line.split() b = list() pairs = ast.literal_eval(a[0]) for p in pairs: b.append("K" + str(p[0]) + str(p[1])) c = list() c.append(b) c.append(a[1]) c.append(ast.literal_eval(a[2])) self.cage_constraints.append(c) # fill variables' list for i in range(0, self.n): for j in range(0, self.n): self.variables.append("K" + str(i) + str(j)) # fill cages' dictionary for constr in self.cage_constraints: for c1 in constr[0]: self.cages[c1] = constr # fill variable domains' dictionary for v in self.variables: self.domains[v] = [i for i in range(1, self.n + 1)] # initialize lists for neighbors' dictionary members for v in self.variables: # initialize neighbors self.neighbors[v] = list() # fill neighbors' dictionary for v1 in self.variables: for v2 in self.variables: # neighbors by row or column constraint if (v1 != v2) and ( (v1[1] == v2[1]) or (v1[2] == v2[2])) and (v2 not in self.neighbors[v1]): self.neighbors[v1].append(v2) # print the structures that we have created so far print("Variables : ", self.variables) print("Domains : ", self.domains) print("Cage constraints : ", self.cage_constraints) #print("Cages : ", self.cages) #print("Neighbors : ", self.neighbors) print("") # in order to change line # initialize CSP CSP.__init__(self, self.variables, self.domains, self.neighbors, self.kenken_constraint)
def __init__(self, grid): """Build a Sudoku problem from a string representing the grid: the digits 1-9 denote a filled cell, '.' or '0' an empty one; other characters are ignored.""" squares = iter(re.findall(r'\d|\.', grid)) domains = {var: [ch] if ch in '123456789' else '123456789' for var, ch in zip(flatten(self.rows), squares)} for _ in squares: raise ValueError("Not a Sudoku grid", grid) # Too many squares def different_values_constraint(A, a, B, b): """A constraint saying two neighboring variables must differ in value.""" return a != b CSP.__init__(self, None, domains, self.neighbors, different_values_constraint)
def __init__(self, columns=5, rowConfigurations=None, columnConfigurations=None): v = None self.board = [[0 for x in range(columns)] for y in range(columns)] self.rows = columns self.columns = columns self.columnConfigurations, self.rowConfigurations = self.setupConstraints( rowConfigurations, columnConfigurations) self.domain = ["Red", "Green", "Red", 0] self.variables = self.board # TODO CSP.__init__(self, self.variables, self.domain, None, None)
def __init__(self, grid): """ Init method of Sudoku class. The parameter grid contains the definition of the sudoku board. This method is devoted to populate the __init_ method of CSP class, creating and passing variables, domains and neighbors from the grid parameter. """ BLOCK_SIZE = 3 BLOCKS_IN_ROW = 3 ROW_SIZE = 9 COL_SIZE = 9 # Variables - # Variables definition. The varibles are an array with a sequence of indexes, from 0 to 80. self.variables = [x for x in range(ROW_SIZE * COL_SIZE)] # Domains - # Domains defintion. In this case of Sudoku CSP, the domains are '123456789' for empty cells and # the value of cell for cells with the default value. original_grid = list(iter(re.findall(r'\d|\.', grid))) domains = {} counter = 0 for item in original_grid: if item == '.': domains[int(counter)] = '123456789' else: value = int(item) restricted_domain = [str(value)] domains[int(counter)] = restricted_domain counter += 1 # Neighbors # Neighbors of binary-constraint definition. This dictionary contains the relations among a cell with its row, # column and block. neighbors = {} # rows # ∀ a # ∀ i ≠ j: xai ≠ xaj for a in range(ROW_SIZE): row_start = a * BLOCKS_IN_ROW * BLOCK_SIZE row_stop = a * BLOCKS_IN_ROW * BLOCK_SIZE + BLOCKS_IN_ROW * BLOCK_SIZE row_indexes = list(range(row_start, row_stop)) for item in row_indexes: neighbors[int(item)] = list() item_neighbors = list(copy.copy(row_indexes)) item_neighbors = [x for x in item_neighbors if x != item] neighbors[int(item)] += item_neighbors # columns # ∀ b # ∀ h ≠ k : xbh ≠ xbk for b in range(COL_SIZE): col_indexes = [ROW_SIZE * a + b for a in range(COL_SIZE)] for item in col_indexes: item_neighbors = list(copy.copy(col_indexes)) item_neighbors = [x for x in item_neighbors if x != item] neighbors[int(item)] += item_neighbors # blocks # A block is a submatrix of sudoku grid: # a = {1, 4, 7}: i, j = [a, a + 2] # b = {1, 4, 7}: k, h = [b, b + 2] # {xpq} p = a...a + 2, q = b...b + 2 ∈ A ∈ N^(3x3) # where # ∀a: i, j = [a, a + 2] # ∀b: k, h = [b, b + 2] # ∀ h ≠ k or i ≠ j: xik ≠ xj, h a = b = [0, 3, 6] for b_row in a: for b_col in b: # block block_items = [] for r in range(3): for c in range(3): block_items.append((b_row + r) * ROW_SIZE + b_col + c) for item in block_items: item_neighbors = list(copy.copy(block_items)) item_neighbors = [x for x in item_neighbors if x != item] neighbors[int(item)] += item_neighbors # remove duplicates for item in neighbors: neighbors[int(item)] = set(neighbors[int(item)]) CSP.__init__(self, None, domains, neighbors, self.different_values_constraint)