def create_nqueens_csp(n = 8):
"""
Return an N-Queen problem on the board of size |n| * |n|.
You should call csp.add_variable() and csp.add_binary_factor().
@param n: number of queens, or the size of one dimension of the board.
@return csp: A CSP problem with correctly configured factor tables
such that it can be solved by a weighted CSP solver.
"""
## idea is that if we limit each queen to to its column, then we just need to choose
# a row for each queen! This reduces domain from n^2 to n.
def onDifferentRowAndDiagonals(v1,v2):
# they are are on different rows
if v1[1] != v2[1]:
if abs(v1[0] - v2[0]) != abs(v1[1] - v2[1]):
return True
return False
def dummyFunction(var):
return 1
csp = util.CSP()
variables = ['q%d'%i for i in range(1, n+1)]
for x in range(len(variables)):
domain = [(x+1, j) for j in range(1,n+1)]
csp.add_variable(variables[x], domain)
csp.add_unary_factor(variables[x], dummyFunction)
for i in range(len(variables)):
for j in range(i+1, len(variables)):
csp.add_binary_factor(variables[i],variables[j], onDifferentRowAndDiagonals)
return csp
def create_nqueens_csp(n=8):
"""
Return an N-Queen problem on the board of size |n| * |n|.
You should call csp.add_variable() and csp.add_binary_factor().
@param n: number of queens, or the size of one dimension of the board.
@return csp: A CSP problem with correctly configured factor tables
such that it can be solved by a weighted CSP solver.
"""
# Problem 1a
domain = range(1, n + 1)
variables = ['x%d' % i for i in range(1, n + 1)]
csp = util.CSP()
for var in variables:
csp.add_variable(var, domain)
for i in range(0, len(variables)):
for j in range(i + 1, len(variables)):
csp.add_binary_factor(
variables[i], variables[j], lambda x, y:
((x != y) and (abs(x - y) != (j - i))))
return csp
def create_nqueens_csp(n = 8):
"""
Return an N-Queen problem on the board of size |n| * |n|.
You should call csp.add_variable() and csp.add_binary_factor().
@param n: number of queens, or the size of one dimension of the board.
@return csp: A CSP problem with correctly configured factor tables
such that it can be solved by a weighted CSP solver.
"""
csp = util.CSP()
# Problem 1a
# BEGIN_YOUR_CODE (our solution is 7 lines of code, but don't worry if you deviate from this)
domains=[]
for i in range(n):
domains.append(i)
for i in range(n):
csp.add_variable(i,domains)
for i in range(n):
for j in range(n):
if i!=j:
csp.add_binary_factor(i,j,lambda x,y: x!=y and abs(y-x)!=abs(j-i) )
#raise Exception("Not implemented yet")
# END_YOUR_CODE
return csp
def create_chain_csp(n):
# same domain for each variable
domain = [0, 1]
# name variables as x_1, x_2, ..., x_n
variables = ['x%d' % i for i in range(1, n + 1)]
csp = util.CSP()
# Problem 0c
# ### START CODE HERE ###
def xor(v1, v2):
return v1 != v2
print(f"n: {n}")
for vi, v in enumerate(variables):
try:
csp.add_variable(v, [0, 1])
if vi > 0:
csp.add_binary_factor(variables[vi - 1], variables[vi], xor)
except Exception as e:
import sys
print(sys.exc_info())
raise RuntimeError(e)
Bsearch = BacktrackingSearch()
Bsearch.solve(csp, ac3=False)
Bsearch.print_stats()
# ### END CODE HERE ###
return csp
def create_nqueens_csp(n=8):
"""
Return an N-Queen problem on the board of size |n| * |n|.
You should call csp.add_variable() and csp.add_binary_factor().
@param n: number of queens, or the size of one dimension of the board.
@return csp: A CSP problem with correctly configured factor tables
such that it can be solved by a weighted CSP solver.
"""
csp = util.CSP()
# Problem 1a
# BEGIN_YOUR_CODE (our solution is 7 lines of code, but don't worry if you deviate from this)
'''
We use string of number 0,1,2......7 to name 8 variable, and each variable have
8 integers to take on, shows that the queen on this row stands on which column.
'''
for r in range(n):
csp.add_variable(str(r), range(n))
for i in range(n):
for j in range(i):
csp.add_binary_factor(
str(i), str(j),
lambda x, y: x != y and abs(i - j) != abs(x - y))
# END_YOUR_CODE
return csp
def create_nqueens_csp(n=8):
"""
Return an N-Queen problem on the board of size |n| * |n|.
You should call csp.add_variable() and csp.add_binary_factor().
@param n: number of queens, or the size of one dimension of the board.
@return csp: A CSP problem with correctly configured factor tables
such that it can be solved by a weighted CSP solver.
"""
csp = util.CSP()
# Problem 1a
# BEGIN_YOUR_CODE (our solution is 7 lines of code, but don't worry if you deviate from this)
def rowCol(x, y):
if x != y:
return 1
return 0
vars = ['var%d' % i for i in range(1, n + 1)]
for i in vars:
csp.add_variable(i, range(n))
for one in range(n):
for two in range(n):
if one != two:
csp.add_binary_factor(
vars[one], vars[two], lambda rowcol1, rowcol2: abs(
rowcol1 - rowcol2) != abs(one - two))
csp.add_binary_factor(vars[one], vars[two], rowCol)
# END_YOUR_CODE
return csp
def create_nqueens_csp(n = 8):
"""
Return an N-Queen problem on the board of size |n| * |n|.
You should call csp.add_variable() and csp.add_binary_factor().
@param n: number of queens, or the size of one dimension of the board.
@return csp: A CSP problem with correctly configured factor tables
such that it can be solved by a weighted CSP solver.
"""
csp = util.CSP()
# Problem 1a
# BEGIN_YOUR_CODE (our solution is 7 lines of code, but don't worry if you deviate from this)
# raise Exception("Not implemented yet")
# define the possible columns and rows for each queen
boardSize = range(n)
# define queens/variables
queens = ['queen%d'%i for i in range(1, n+1)]
# add variables and assiociate possible positions to csp
for var in queens:
csp.add_variable(var,boardSize)
# add binary factors
for firstIndex in range(n):
for secondIndex in range(firstIndex+1, n):
# check if on the same row and column
csp.add_binary_factor(queens[firstIndex], queens[secondIndex], lambda rowcolumnVal1, rowcolumnVal2: rowcolumnVal1 != rowcolumnVal2)
# check if on the diagonal
csp.add_binary_factor(queens[firstIndex], queens[secondIndex], lambda rowcolumnVal1, rowcolumnVal2: abs(rowcolumnVal1 - rowcolumnVal2) != abs(firstIndex - secondIndex))
# END_YOUR_CODE
return csp
def create_nqueens_csp(n=8):
"""
Return an N-Queen problem on the board of size |n| * |n|.
You should call csp.add_variable() and csp.add_binary_factor().
@param n: number of queens, or the size of one dimension of the board.
@return csp: A CSP problem with correctly configured factor tables
such that it can be solved by a weighted CSP solver.
"""
csp = util.CSP()
# Problem 1a
# BEGIN_YOUR_CODE (our solution is 7 lines of code, but don't worry if you deviate from this)
# Domain specifies which column the queen will go on.
domain = [i for i in range(n)]
# Each variable corresponds to a queen in a given row. ie q0 is the variable for the queen
# on row 0. If q0 == 1, this means this queen is at position (0, 1) on the board.
variables = ['q%d' % i for i in range(n)]
[csp.add_variable(variable, domain) for variable in variables]
[
csp.add_binary_factor(
variables[row1], variables[row2], lambda col1, col2: 1
if col1 != col2 and abs(row1 - row2) != abs(col1 - col2) else 0)
for row2 in range(n) for row1 in range(row2 + 1, n)
]
# END_YOUR_CODE
return csp
def create_nqueens_csp(n=8):
"""
Return an N-Queen problem on the board of size |n| * |n|.
You should call csp.add_variable() and csp.add_binary_factor().
@param n: number of queens, or the size of one dimension of the board.
@return csp: A CSP problem with correctly configured factor tables
such that it can be solved by a weighted CSP solver.
"""
csp = util.CSP()
# Problem 1a
# BEGIN_YOUR_CODE (our solution is 7 lines of code, but don't worry if you deviate from this)
domain = [i in range(1, n + 1)]
variables = ['x%d' % i for i in range(1, n + 1)]
prevVar = None
for var in variables:
csp.add_variable(var, domain)
if prevVar != None:
csp.add_binary_factor(
prevVar, var,
lambda x, y: x != y - 1 and x != y and x != y + 1)
prevVar = var
# END_YOUR_CODE
return csp
def create_nqueens_csp(n=8):
"""
Return an N-Queen problem on the board of size |n| * |n|.
You should call csp.add_variable() and csp.add_binary_factor().
@param n: number of queens, or the size of one dimension of the board.
@return csp: A CSP problem with correctly configured factor tables
such that it can be solved by a weighted CSP solver.
"""
csp = util.CSP()
# Problem 1a
# BEGIN_YOUR_CODE (our solution is 7 lines of code, but don't worry if you deviate from this)
variables = ['q%d' % (i + 1) for i in range(n)]
domain = list(range(n))
for i, v in enumerate(variables):
csp.add_variable(v, zip([i] * n, domain))
for v1 in variables:
for v2 in variables:
if v1 == v2:
continue
csp.add_binary_factor(v1, v2, lambda v1, v2: v1[1] != v2[1])
csp.add_binary_factor(
v1, v2, lambda v1, v2: v1[0] + v1[1] != v2[0] + v2[1])
csp.add_binary_factor(
v1, v2, lambda v1, v2: v1[0] - v1[1] != v2[0] - v2[1])
# END_YOUR_CODE
return csp
def create_nqueens_csp(n=8):
"""
Return an N-Queen problem on the board of size |n| * |n|.
You should call csp.add_variable() and csp.add_binary_factor().
@param n: number of queens, or the size of one dimension of the board.
@return csp: A CSP problem with correctly configured factor tables
such that it can be solved by a weighted CSP solver.
"""
csp = util.CSP()
# Problem 1a
# BEGIN_YOUR_CODE (our solution is 7 lines of code, but don't worry if you deviate from this)
variables = ['x%d' % i for i in range(1, n + 1)]
for index, variable in enumerate(variables):
csp.add_variable(variable, [(index, i) for i in range(0, n)])
for index, variable in enumerate(variables):
for index2, variable2 in enumerate(variables):
if index != index2:
csp.add_binary_factor(variable, variable2,
lambda x, y: x[1] != y[1])
csp.add_binary_factor(
variable, variable2, lambda x, y: (x[0] - x[1]) !=
(y[0] - y[1]))
csp.add_binary_factor(
variable, variable2, lambda x, y: (x[0] + x[1]) !=
(y[0] + y[1]))
# END_YOUR_CODE
return csp
def create_nqueens_csp(n=8):
"""
Return an N-Queen problem on the board of size |n| * |n|.
You should call csp.add_variable() and csp.add_binary_factor().
@param n: number of queens, or the size of one dimension of the board.
@return csp: A CSP problem with correctly configured factor tables
such that it can be solved by a weighted CSP solver.
"""
csp = util.CSP()
# Problem 1a
# BEGIN_YOUR_CODE (our solution is 7 lines of code, but don't worry if you deviate from this)
def f(a, b): # a and b are values where value is row + ' ' + column
values = a.split(' ')
ar = int(values[0])
ac = int(values[1])
values = b.split(' ')
br = int(values[0])
bc = int(values[1])
if (ar == br or ac == bc or (ar == br and ac == bc)
or (abs(ar - br) == abs(ac - bc))):
return 0
return 1
for i in range(n):
csp.add_variable(
i, [str(i) + ' ' + str(j) for j in range(n)
]) # example: first queen is in first(zero) row and 0-1 column
for i in range(n - 1):
for j in range(i + 1, n):
csp.add_binary_factor(i, j, f)
# END_YOUR_CODE
return csp
def create_nqueens_csp(n=8):
"""
Return an N-Queen problem on the board of size |n| * |n|.
You should call csp.add_variable() and csp.add_binary_potential().
@param n: number of queens, or the size of one dimension of the board.
@return csp: A CSP problem with correctly configured potential tables
such that it can be solved by a weighted CSP solver.
"""
csp = util.CSP()
# Problem 1a
# BEGIN_YOUR_CODE (around 10 lines of code expected)
# add variable:
variables = ['Queen_%d' % i for i in range(n)]
for i in range(n):
var = variables[i]
domain = [(i, j) for j in range(n)] # queen i must on row i
csp.add_variable(var, domain)
# add potential:
for i in range(n):
for j in range(n):
if i == j: continue
csp.add_binary_potential(
variables[i], variables[j], lambda a, b:
(a[0] != b[0]) and (a[1] != b[1]) and
(a[0] - b[0] != a[1] - b[1]) and (a[0] - b[0] != -a[1] + b[1]))
# END_YOUR_CODE
return csp
def create_nqueens_csp(n=8):
"""
Return an N-Queen problem on the board of size |n| * |n|.
You should call csp.add_variable() and csp.add_binary_factor().
@param n: number of queens, or the size of one dimension of the board.
@return csp: A CSP problem with correctly configured factor tables
such that it can be solved by a weighted CSP solver.
"""
csp = util.CSP()
# Problem 1a
# BEGIN_YOUR_CODE (around 10 lines of code expected)
domain = range(n)
variables = ['q%d' % i for i in range(0, n)]
for v in variables:
csp.add_variable(v, domain)
for i in range(n):
for j in range(i + 1, n):
# the same row
csp.add_binary_factor(variables[i], variables[j],
lambda x, y: x != y)
csp.add_binary_factor(variables[i], variables[j],
lambda x, y: x != y + (j - i))
csp.add_binary_factor(variables[i], variables[j],
lambda x, y: x != y - (j - i))
# END_YOUR_CODE
return csp
def create_nqueens_csp(n=8):
"""
Return an N-Queen problem on the board of size |n| * |n|.
You should call csp.add_variable() and csp.add_binary_potential().
@param n: number of queens, or the size of one dimension of the board.
@return csp: A CSP problem with correctly configured potentials
such that it can be solved by a weighted CSP solver.
"""
csp = util.CSP()
# BEGIN_YOUR_CODE (around 7 lines of code expected)
queen_pos = list(range(
n)) # each element is the row position of its queen for column `idx`
domain = list(range(n))
for pos in queen_pos:
csp.add_variable(pos, domain)
for i in range(n):
for j in range(n):
if i != j:
# row constraint
csp.add_binary_potential(queen_pos[i], queen_pos[j],
lambda x, y: x != y)
# diagonal constraint
csp.add_binary_potential(queen_pos[i], queen_pos[j],
lambda x, y: abs(i - j) != abs(x - y))
# END_YOUR_CODE
return csp
def create_zebra_problem():
csp = util.CSP()
domain = list(range(1, 6))
variables = [
'Englishmen', 'Spaniard', 'Norwegian', 'Japanese', 'Ukrainian',
'coffee', 'milk', 'orange-juice', 'tea', 'water', 'dog', 'horse',
'fox', 'zebra', 'snail', 'red', 'yellow', 'blue', 'green', 'ivory',
'kitkats', 'snickers', 'smarties', 'hershey', 'milkyways'
]
for var in variables:
csp.add_variable(var, domain)
csp.add_binary_potential('Englishmen', 'red', lambda x, y: x == y)
csp.add_binary_potential('Spaniard', 'dog', lambda x, y: x == y)
csp.add_unary_potential('Norwegian', lambda x: x == 1)
csp.add_binary_potential('green', 'ivory', lambda x, y: x == y + 1)
csp.add_binary_potential('hershey', 'fox', lambda x, y: abs(x - y) == 1)
csp.add_binary_potential('kitkats', 'yellow', lambda x, y: x == y)
csp.add_binary_potential('Norwegian', 'blue', lambda x, y: abs(x - y) == 1)
csp.add_binary_potential('smarties', 'snail', lambda x, y: x == y)
csp.add_binary_potential('snickers', 'orange-juice', lambda x, y: x == y)
csp.add_binary_potential('Ukrainian', 'tea', lambda x, y: x == y)
csp.add_binary_potential('Japanese', 'milkyways', lambda x, y: x == y)
csp.add_binary_potential('kitkats', 'horse', lambda x, y: abs(x - y) == 1)
csp.add_binary_potential('coffee', 'green', lambda x, y: x == y)
csp.add_unary_potential('milk', lambda x: x == 3)
for idx1 in range(5):
for idx2 in range(5):
if idx1 != idx2:
csp.add_binary_potential(variables[idx1], variables[idx2],
lambda x, y: x != y)
for idx1 in range(5, 10):
for idx2 in range(5, 10):
if idx1 != idx2:
csp.add_binary_potential(variables[idx1], variables[idx2],
lambda x, y: x != y)
for idx1 in range(10, 15):
for idx2 in range(10, 15):
if idx1 != idx2:
csp.add_binary_potential(variables[idx1], variables[idx2],
lambda x, y: x != y)
for idx1 in range(15, 20):
for idx2 in range(15, 20):
if idx1 != idx2:
csp.add_binary_potential(variables[idx1], variables[idx2],
lambda x, y: x != y)
for idx1 in range(20, 25):
for idx2 in range(20, 25):
if idx1 != idx2:
csp.add_binary_potential(variables[idx1], variables[idx2],
lambda x, y: x != y)
return csp
def test2b_2():
csp = util.CSP()
sumVar = submission.get_sum_variable(csp, 'zero', [], 15)
sumSolver = submission.BacktrackingSearch()
sumSolver.solve(csp)
csp.add_unary_factor(sumVar, lambda n: n > 0)
sumSolver = submission.BacktrackingSearch()
sumSolver.solve(csp)
def create_chain_csp(n):
# same domain for each variable
domain = [0, 1]
# name variables as x_1, x_2, ..., x_n
variables = ['x%d' % i for i in range(1, n + 1)]
csp = util.CSP()
# Problem 0c
# BEGIN_YOUR_CODE (our solution is 4 lines of code, but don't worry if you deviate from this)
raise Exception("Not implemented yet")
# END_YOUR_CODE
return csp
def get_basic_csp(self):
"""
Return a CSP that only enforces the basic constraints that a course can
only be taken when it's offered and that a request can only be satisfied
in at most one semester.
@return csp: A CSP where basic variables and constraints are added.
"""
csp = util.CSP()
self.add_variables(csp)
self.add_bulletin_constraints(csp)
return csp
def test_1(self):
"""2b-1-hidden: Test get_sum_variable with empty list of variables."""
csp = util.CSP()
sumVar = submission.get_sum_variable(csp, 'zero', [], 15)
sumSolver = submission.BacktrackingSearch()
sumSolver.solve(csp)
# BEGIN_HIDE
# END_HIDE
csp.add_unary_factor(sumVar, lambda n: n > 0)
sumSolver = submission.BacktrackingSearch()
sumSolver.solve(csp)
def test2b_3():
csp = util.CSP()
csp.add_variable('A', [0, 1, 2])
csp.add_variable('B', [0, 1, 2])
csp.add_variable('C', [0, 1, 2])
sumVar = submission.get_sum_variable(csp, 'sum-up-to-7', ['A', 'B', 'C'], 7)
sumSolver = submission.BacktrackingSearch()
sumSolver.solve(csp)
csp.add_unary_factor(sumVar, lambda n: n == 6)
sumSolver = submission.BacktrackingSearch()
sumSolver.solve(csp)
def create_chain_csp(n):
# same domain for each variable
domain = [0, 1]
# name variables as x_1, x_2, ..., x_n
variables = ['x%d' % i for i in range(1, n + 1)]
csp = util.CSP()
# Problem 0c
for i, var in enumerate(variables):
csp.add_variable(var, domain)
if i > 0:
csp.add_binary_factor(variables[i - 1], variables[i],
lambda x, y: x != y)
return csp
def create_nqueens_csp(n=8):
"""
Return an N-Queen problem on the board of size |n| * |n|.
You should call csp.add_variable() and csp.add_binary_factor().
@param n: number of queens, or the size of one dimension of the board.
@return csp: A CSP problem with correctly configured factor tables
such that it can be solved by a weighted CSP solver.
"""
csp = util.CSP()
# Problem 1a
# ### START CODE HERE ###
print(f"n: {n}")
try:
def check_row_diag(r1=None, r2=None, k=None):
def diff_row_diff_diag(r1, r2):
if r1 == r2:
return 0
if abs(r1 - r2) == k:
return 0
return 1
return diff_row_diff_diag
except Exception as e:
import sys
print(sys.exc_info())
raise RuntimeError(str(e))
domain = list(range(n))
for vi in range(n):
try:
csp.add_variable(f"v_{vi}", domain)
for vj in range(vi):
k = vi - vj
f_k = check_row_diag(k=k)
csp.add_binary_factor(f"v_{vi}", f"v_{vj}", f_k)
except Exception as e:
import sys
print(sys.exc_info())
raise RuntimeError(e)
Bsearch = BacktrackingSearch()
Bsearch.solve(csp)
# Bsearch.print_stats()
# ### END CODE HERE ###
return csp
def create_chain_csp(n):
# same domain for each variable
domain = [0, 1]
# name variables as x_1, x_2, ..., x_n
variables = ['x%d'%i for i in range(1, n+1)]
csp = util.CSP()
# Problem 0c
def xor(v1, v2):
return v1!= v2
for i in range(len(variables)):
csp.add_variable(variables[i], domain)
if i >0:
csp.add_binary_factor(variables[i-1],variables[i],xor)
return csp
def create_chain_csp(n):
# same domain for each variable
domain = [0, 1]
# name variables as x_1, x_2, ..., x_n
variables = ['x%d' % i for i in range(1, n + 1)]
csp = util.CSP()
# Problem 0c
# BEGIN_YOUR_CODE (around 5 lines of code expected)
for i, v in enumerate(variables):
csp.add_variable(v, domain)
if (i > 0):
csp.add_binary_factor(variables[i - 1], v, lambda x, y: x != y)
# END_YOUR_CODE
return csp
def make_teams(player_filename = "./PredictionsData/12.8.2015.csv"):
csp = util.CSP()
#Read in players
players = make_player_dict(player_filename)
#Make a variable for each position
add_position_variables(csp, players)
#Ensure no position chooses the same player as another
add_same_player_constraints(csp, players)
#Ensure that total salary is under the limit
add_salary_constraints(csp, players)
#Add assignment weights
add_weights(csp, players)
#ipdb.set_trace()
return get_beamsearch_results(csp, players)
def create_chain_csp(n):
# same domain for each variable
domain = [0, 1]
# name variables as x_1, x_2, ..., x_n
variables = ['x%d' % i for i in range(1, n + 1)]
csp = util.CSP()
# Problem 0c
# BEGIN_YOUR_CODE (our solution is 4 lines of code, but don't worry if you deviate from this)
for index in range(len(variables)):
csp.add_variable(variables[index], domain)
if index > 0:
csp.add_binary_factor(variables[index - 1], variables[index],
lambda a, b: a != b)
# END_YOUR_CODE
return csp
def create_chain_csp(n):
# same domain for each variable
domain = [0, 1]
# name variables as x_1, x_2, ..., x_n
variables = ['x%d' % i for i in range(1, n + 1)]
csp = util.CSP()
# Problem 0c
# BEGIN_YOUR_CODE (around 5 lines of code expected)
for var in variables:
csp.add_variable(var, domain)
for i in range(n - 1):
csp.add_binary_potential(variables[i], variables[i + 1],
lambda a, b: a != b)
# END_YOUR_CODE
return csp
def create_chain_csp(n):
# same domain for each variable
domain = [0, 1]
# name variables as x_1, x_2, ..., x_n
variables = ['x%d' % i for i in range(1, n + 1)]
csp = util.CSP()
# Problem 0c
# BEGIN_YOUR_CODE (our solution is 5 lines of code, but don't worry if you deviate from this)
for v in variables:
csp.add_variable(v, domain)
for i in range(len(variables) - 1):
csp.add_binary_factor(variables[i], variables[i + 1],
lambda d1, d2: d1 ^ d2)
# END_YOUR_CODE
return csp
def create_chain_csp(n):
# same domain for each variable
domain = [0, 1]
# name variables as x_1, x_2, ..., x_n
variables = ['x%d'%i for i in range(1, n+1)]
csp = util.CSP()
# Problem 0c
# BEGIN_YOUR_CODE (our solution is 4 lines of code, but don't worry if you deviate from this)
variables = [f'X{i}' for i in range(1, n + 1)]
for i in range(n):
csp.add_variable(variables[i], [0, 1])
for i in range(n-1):
csp.add_binary_factor(variables[i], variables[i+1], lambda x, y: x ^ y) # ^ is XOR
# END_YOUR_CODE
return csp
