def main():
f = open("input/input90.txt", "r")
Lines = f.readlines()
f.close()
print("Reading file")
graph, color = readFile(Lines)
print("File reading complete! Start CSP graph coloring.")
variables = graph.vertices()
domains = {}
for variable in variables:
domains[variable] = [i for i in range(color)]
csp = CSP(variables, domains)
for constraint in graph.edges():
(vertex1, vertex2) = tuple(constraint)
csp.add_constraint(GraphColoringConstraint(vertex1, vertex2))
assignment = {}
solution = backtracking_search(csp, assignment, domains)
if solution is None:
print("No solution!")
else:
print("Result of graph coloring:")
print(sorted(solution.items(), key=operator.itemgetter(0)))
if check(solution, graph):
print("Algorithm correct!")
else:
print("Something went wrong!")
def main():
grid = Grid(15)
words = [
"Mathew",
"Joe",
"Marry",
"Sarah",
"Sally",
"constraint",
"satisfaction",
"problem",
]
locations = {}
for word in words:
locations[word] = grid.generate_domain(len(word))
csp = CSP(words, locations)
csp.add_constraint(WordSearchConstraint(words))
solution = csp.backtracking_search()
if solution is None:
print("No Solution Found")
else:
for word, grid_locations in solution.items():
# Randomly reverse words 1/2 the time
if choice([True, False]):
grid_locations.reverse()
for index, letter in enumerate(word):
(row, col) = (grid_locations[index].row,
grid_locations[index].column)
grid.grid[row][col] = letter.upper()
print(grid)
def main():
columns = [x for x in range(1, 9)]
rows = {}
for column in columns:
rows[column] = [x for x in range(1, 9)]
csp = CSP(columns, rows)
csp.add_constraint(QueenConstraint(columns))
solution = csp.backtracking_search()
if solution is None:
print("No Solution Found!")
else:
print(solution)
def main():
grid = Graph()
colors = {}
# clues = make_min_clues() # Takes a long! time
clues = make_clues_easy()
for vertex in grid.vertices:
colors[vertex] = [c for c in range(1, 10)]
csp = CSP(grid.vertices, colors)
csp.add_constraint(ColoringConstraint(grid.vertices))
before = time()
solution = csp.backtracking_search(assignment=clues)
print(f"Time Elapsed: {time() - before:.3}s")
if solution is None:
print("No Solution Found")
else:
for vert, color in solution.items():
print(vert, f"Color: {color}")
def main():
word_1 = "SEND"
word_2 = "MORE"
sum_word = "MONEY"
letters = set([letter for letter in word_1 + word_2 + sum_word])
possible_digits = {}
for letter in set([letter for letter in word_1 + word_2 + sum_word]):
possible_digits[letter] = [x for x in range(10)]
# possible_digits['M'] = [x for x in range(1, 10)] # To prevent answers starting with a Zero
csp = CSP(letters, possible_digits)
csp.add_constraint(SendMoreMoneyConstraint(word_1, word_2, sum_word, letters))
solution = csp.backtracking_search()
if solution is None:
print("No Solution Found")
else:
print(solution)
def main():
GRID_SIZE = 9
CB = CircuitBoard(GRID_SIZE)
boxes = (
# From Book
"44",
"33",
"22",
"61",
"25",
# More Squares
"31",
"17",
"23",
"11",
"41",
"32",
"51",
"14",
# 9x9 area is full
)
locations = {}
for box in boxes:
locations[box] = CB.generate_domain(int(box[0]), int(box[1]))
csp = CSP(boxes, locations)
csp.add_constraint(CircuitBoardConstraint(boxes))
solution = csp.backtracking_search()
if solution is None:
print("No Solution Found")
else:
for box, grid_locations in solution.items():
print(
f"Box: {box},"
f"Grid Location: {[gl.__str__() for gl in grid_locations]},"
f"Area: {len(grid_locations)}\n"
)
print_grid(solution, GRID_SIZE)
m = assignment['M']
o = assignment['O']
r = assignment['R']
y = assignment['Y']
send = s * 1000 + e * 100 + n * 10 + d
more = m * 1000 + o * 100 + r * 10 + e
money = m * 10000 + o * 1000 + n * 100 + e * 10 + y
return send + more == money
# No conflict, ensures partial solution can continue to be worked on
return True
if __name__ == '__main__':
letters = list('SENDMORY')
possible_digits = {}
for letter in letters:
possible_digits[letter] = list(range(10))
possible_digits['M'] = [1] # So we don't get answers starting with a 0
csp = CSP(letters, possible_digits)
csp.add_constraint(SendMoreMoneyConstraint(letters))
solution = csp.backtracking_search()
if solution is None:
print('No solution found!')
else:
print(solution)
class QueensConstraint(Constraint[int, int]):
def __init__(self, columns: List[int]) -> None:
super().__init__(columns)
self.columns: List[int] = columns
def satisfied(self, assignment: Dict[int, int]) -> bool:
for q1c, q1r in assignment.items():
for q2c in range(q1c + 1, len(self.columns) + 1):
if q2c in assignment:
q2r: int = assignment[q2c]
if q1r == q2r:
return False
if abs(q1r - q2r) == abs(q1c - q2c):
return False
return True
if __name__ == "__main__":
columns = [1, 2, 3, 4, 5, 6, 7, 8]
rows = {}
for column in columns:
rows[column] = [1, 2, 3, 4, 5, 6, 7, 8]
csp = CSP(columns, rows)
csp.add_constraint(QueensConstraint(columns))
solution = csp.backtracking_search()
if solution is None:
print("No solution found!")
else:
print(solution)
class MapColoringProblem:
def __init__(self, points_number, map_width, map_height):
self.csp: Optional[CSP] = None
self.points: List[List[int]] = []
self.connections: List[List[int]] = []
self.width = map_width
self.height = map_height
self.points_number = points_number
for i in range(0, points_number):
self.connections.append([])
self.colors = {}
def init_problem(self, colors_number):
if self.points == []:
raise ProblemNotInitializedException()
variables: List[Tuple[int, int]] = []
for p in self.points:
variables.append((p[0], p[1]))
domains: Dict[Tuple[int, int], List[int]] = {}
domain = []
for i in range(1, colors_number + 1):
domain.append(i)
for variable in variables:
domains[variable] = copy.deepcopy(domain)
self.csp = CSP(variables, domains)
self.add_constraints()
def add_constraints(self):
constraints = []
for p in self.points:
for p2_idx in self.connections[self.points.index(p)]:
p2 = self.points[p2_idx]
if not (p, p2) in constraints and not (p2, p) in constraints:
constraints.append((p, p2))
# self.csp.add_constraint(MapColoringConstraint((p[0], p[1]), (p2[0], p2[1])))
for c in constraints:
self.csp.add_constraint(
MapColoringConstraint((c[0][0], c[0][1]), (c[1][0], c[1][1])))
def solve(self):
if self.csp == None:
raise ProblemNotInitializedException()
else:
solutions = self.csp.backtracking_search(
evaluate=self.csp.forward_checking, only_first_result=True)
if solutions == []:
print("No solution found...")
else:
self.print_solutions(solutions)
self.get_colors_from_solutions(solutions)
def get_colors_from_solutions(self, solutions):
i = 0
for solution in solutions:
self.colors[i] = []
for point in self.points:
self.colors[i].append(solution[(point[0], point[1])])
i += 1
def print_solutions(self, solutions):
for solution in solutions:
for k in solution:
color = ""
if solution[k] == 1:
color = "Blue"
elif solution[k] == 2:
color = "Green"
elif solution[k] == 3:
color = "Red"
elif solution[k] == 4:
color = "Yellow"
elif solution[k] == 5:
color == "Light green"
else:
color = solution[k]
print(f"Point: {k}, color: {color}")
print()
print("Visited Nodes:", self.csp.visited_nodes)
def generate_map(self):
for i in range(self.points_number):
while True:
x = randint(1, self.width - 1)
y = randint(1, self.height - 1)
if [x, y] not in self.points:
self.points.append([x, y])
break
self.generate_connections()
def print_map(self):
if self.points == []:
raise ProblemNotInitializedException()
if self.colors == []:
raise SolutionNotResolvedException()
i = 0
for k in self.colors.keys():
colors = self.colors[k]
print(colors)
json = {
"board": self.width,
"regions": copy.deepcopy(self.points),
"colors": colors,
#"colors": [5, 5, 5, 5, 5],
"connections": self.connections
}
#print(json)
drawer = BoardDrawer(json)
im = drawer.get_image()
output_path = f"map_images/generated_map_{i+1}.png"
im.save(output_path)
i += 1
def generate_connections(self):
done_points = []
while len(done_points) < len(self.points):
for p in self.points:
neighbour = self.find_closest(p)
if neighbour:
self.connections[self.points.index(p)].append(
self.points.index(neighbour))
self.connections[self.points.index(neighbour)].append(
self.points.index(p))
else:
if p not in done_points:
done_points.append(p)
def find_closest(self, point) -> List[int]:
min_distance = self.width * self.height
closest = None
pt_index = self.points.index(point)
for other in self.points:
if other != point and self.points.index(
other) not in self.connections[pt_index]:
if not self.intersects(point, other):
distance = self.calculate_distance(point, other)
if distance < min_distance:
closest = other
min_distance = distance
return closest
def intersects(self, point1, point2):
for p1 in self.points:
for p2_idx in self.connections[self.points.index(p1)]:
p2 = self.points[p2_idx]
int_pt = tools.find_intersection(point1, point2, p1, p2)
if int_pt != None and int_pt != point1 and int_pt != point2:
return True
# if tools.intersects(point1, point2, p1, p2):
# return True
return False
def calculate_distance(self, point, other):
a = other[0] - point[0]
b = other[1] - point[1]
return math.sqrt(a * a + b * b)
self.place2 = place2
def satisfied(self, assignment: Dict[str, str]) -> bool:
if self.place1 not in assignment or self.place2 not in assignment:
return True
return assignment[self.place1] != assignment[self.place2]
if __name__ == "__main__":
variables = ["Western Australia", "Northern Territory", "South Australia",
"Queensland", "New South Wales", "Victoria", "Tasmania"]
domains = {}
for variable in variables:
domains[variable] = ["red", "blue", "green"]
csp = CSP(variables, domains)
csp.add_constraint(MapColoringConstraint(
"Western Australia", "Northern Territory"))
csp.add_constraint(MapColoringConstraint(
"Western Australia", "South Australia"))
csp.add_constraint(MapColoringConstraint(
"South Australia", "Northern Territory"))
csp.add_constraint(MapColoringConstraint(
"Queensland", "Northern Territory"))
csp.add_constraint(MapColoringConstraint("Queensland", "South Australia"))
csp.add_constraint(MapColoringConstraint("Queensland", "New South Wales"))
csp.add_constraint(MapColoringConstraint(
"New South Wales", "South Australia"))
csp.add_constraint(MapColoringConstraint("Victoria", "South Australia"))
csp.add_constraint(MapColoringConstraint("Victoria", "New South Wales"))
csp.add_constraint(MapColoringConstraint("Victoria", "Tasmania"))
solution = csp.backtracking_search()
]
return len(set(all_locations)) == len(all_locations)
if __name__ == '__main__':
grid = generate_grid(9, 9)
words = [
name.upper() for name in ['matthew', 'joe', 'mary', 'sarah', 'sally']
]
locations = {}
for word in words:
locations[word] = generate_domain(word, grid)
csp = CSP(words, locations)
csp.add_constraint(WordSearchConstraint(words))
solution = csp.backtracking_search()
if solution is None:
print('No solution found!')
else:
for word, grid_locations in solution.items():
# Random reverse half the time
if choice([True, False]):
grid_locations.reverse()
for index, letter in enumerate(word):
row, column = grid_locations[index].row, grid_locations[
index].column
grid[row][column] = letter
super().__init__(words)
self.words: List[str] = words
def satisfied(self, assignment: Dict[str, List[GridLocation]]) -> bool:
all_locations = [
locs for value in assignment.values() for locs in value
]
return len(set(all_locations)) == len(all_locations)
if __name__ == "__main__":
grid = generate_grid(9, 9)
words = ["MATTHEW", "JOE", "MARY", "SARAH", "SALLY"]
locations = {}
for word in words:
locations[word] = generate_domain(word, grid)
csp = CSP(words, locations)
csp.add_constraint(WordConstraint(words))
solution = csp.backtracking_search()
if solution is None:
print("No solution found!")
else:
for word, grid_locations in solution.items():
if choice([True, False]):
grid_locations.reverse()
for index, letter in enumerate(word):
(row, col) = (grid_locations[index].row,
grid_locations[index].column)
grid[row][col] = letter
display_grid(grid)
variables = [
'Western Australia',
'Northern Territory',
'South Australia',
'Queensland',
'New South Wales',
'Victoria',
'Tasmania'
]
domains = {}
for variable in variables:
domains[variable] = ['red', 'green', 'blue']
csp = CSP(variables, domains)
csp.add_constraint(MapColoringConstraint('Western Australia', 'Northern Territory'))
csp.add_constraint(MapColoringConstraint('Western Australia', 'South Australia'))
csp.add_constraint(MapColoringConstraint('South Australia', 'Northern Territory'))
csp.add_constraint(MapColoringConstraint('Queensland', 'Northern Territory'))
csp.add_constraint(MapColoringConstraint('Queensland', 'South Australia'))
csp.add_constraint(MapColoringConstraint('Queensland', 'New South Wales'))
csp.add_constraint(MapColoringConstraint('New South Wales', 'South Australia'))
csp.add_constraint(MapColoringConstraint('Victoria', 'South Australia'))
csp.add_constraint(MapColoringConstraint('Victoria', 'New South Wales'))
csp.add_constraint(MapColoringConstraint('Victoria', 'Tasmania'))
solution = csp.backtracking_search()
if solution is None:
print("No solution found!")
else:
def main():
variables = [
"W. Aus",
"N. Ter",
"S. Aus",
"Queensland",
"New S. Wales",
"Victoria",
"Tasmania",
]
domains = {}
for var in variables:
domains[var] = ["red", "green", "blue"]
csp = CSP(variables, domains)
csp.add_constraint(MapColoringConstraint("W. Aus", "N. Ter"))
csp.add_constraint(MapColoringConstraint("W. Aus", "S. Aus"))
csp.add_constraint(MapColoringConstraint("N. Ter", "Queensland"))
csp.add_constraint(MapColoringConstraint("N. Ter", "S. Aus"))
csp.add_constraint(MapColoringConstraint("S. Aus", "Queensland"))
csp.add_constraint(MapColoringConstraint("S. Aus", "New S. Wales"))
csp.add_constraint(MapColoringConstraint("S. Aus", "Victoria"))
csp.add_constraint(MapColoringConstraint("Queensland", "New S. Wales"))
csp.add_constraint(MapColoringConstraint("New S. Wales", "Victoria"))
csp.add_constraint(MapColoringConstraint("Victoria", "Tasmania"))
solution = csp.backtracking_search()
if solution is None:
print("No Solution Found")
else:
print(solution)
from animals import Animals, animals_list from zones import zones from constraints import ( NotSameZoneConstraint, OnlySameZoneConstraint, NotAdjascentZoneConstraint, FirstZoneConstraint ) if __name__ == "__main__": tic = time.time() problem = CSP(animals_list, zones) problem.add_constraint(FirstZoneConstraint(Animals.LEAO)) problem.add_constraint(NotSameZoneConstraint(Animals.LEAO, Animals.TIGRE)) problem.add_constraint(NotSameZoneConstraint(Animals.LEAO, Animals.PAVAO)) problem.add_constraint(NotSameZoneConstraint(Animals.TIGRE, Animals.PAVAO)) problem.add_constraint(NotSameZoneConstraint(Animals.TIGRE, Animals.SURICATO)) problem.add_constraint(NotSameZoneConstraint(Animals.TIGRE, Animals.JAVALI)) problem.add_constraint(NotSameZoneConstraint(Animals.HIENA, Animals.LEAO)) problem.add_constraint(NotSameZoneConstraint(Animals.HIENA, Animals.ANTILOPE)) problem.add_constraint(NotSameZoneConstraint(Animals.HIENA, Animals.PAVAO)) problem.add_constraint(NotSameZoneConstraint(Animals.HIENA, Animals.SURICATO)) problem.add_constraint(NotSameZoneConstraint(Animals.HIENA, Animals.JAVALI)) problem.add_constraint(OnlySameZoneConstraint(Animals.SURICATO, Animals.JAVALI))
