def reduceGroups(groups):
# Rule 1: HashSet cardinality and number of dups.
for group in groups:
for current_cell in group:
dups = 0
for other_cell in group:
if other_cell == current_cell:
dups += 1
if (dups == len(current_cell)) and (dups < 9):
for other_cell in group:
if other_cell != current_cell and current_cell <= other_cell:
other_cell.difference_update(current_cell)
return True
# Rule 2: HashSet difference when size = 1. Make a new copy of the item we are currently at.
for group in groups:
for i in range(0, len(group)):
set_copy = HashSet(group[i])
current_index = i
for j in range(0, len(group)):
if j != current_index:
set_copy.difference_update(group[j])
if len(set_copy) == 1 and set_copy != group[i]:
group[i].clear()
group[i].update(set_copy)
return True
return False
def test_contains(self):
elements = [2, 4, 6, 8]
hs = HashSet(elements)
assert hs.contains(2) is True
assert hs.contains(4) is True
assert hs.contains(8) is True
assert hs.contains(20) is False
def buildPuzzle(file):
puzzle = []
for line in file:
line = line.strip("\n")
line = line.split()
isEmpty = False
if len(line) == 0:
isEmpty = True
rowEntry = []
if not isEmpty:
counter = 0
for item in line:
counter += 1
if item == "x":
rowEntry.append(HashSet([1, 2, 3, 4, 5, 6, 7, 8, 9]))
else:
try:
rowEntry.append(HashSet([int(item)]))
except:
print(
"Your puzzle is in an invalid format. Please include only numbers seperated by a space."
)
file.close()
return
puzzle.append(rowEntry)
if counter != 9:
print(
"Your puzzle is in an invalid format. Please include only numbers seperated by a space."
)
file.close()
return
file.close()
return puzzle
def test_init_with_list(self):
data = [8, 5, 1]
hs = HashSet(data)
assert hs.size == 3
assert hs.contains(8) == True
assert hs.contains(5) == True
assert hs.contains(1) == True
def test_intersection(self):
first_set = HashSet(['One', 'Two', 'Three', 'Four'])
second_set = HashSet(['Red', 'Two', 'Three', 'Orange'])
intersection = first_set.intersection(second_set)
assert intersection.size == 2
assert intersection.contains('Two')
assert intersection.contains('Three')
def Q1(Random, capacity):
"""
Parameter:
Random takes in True/False
if True, insert integers randomly.
Capacity takes in initial array capacity.
"""
hashSet = HashSet([], capacity)
listOf400 = list(range(1, 401))
numberLeft = 400
elapsedTimeTotal = 0
while numberLeft > 0:
index = (random.randint(0, numberLeft - 1))
if Random:
addNumber = listOf400.pop(index)
else:
addNumber = listOf400.pop(0)
startTime = time.time()
hashSet.add(addNumber)
endTime = time.time()
elapsedTimeTotal += round(endTime - startTime, 10)
numberLeft -= 1
print("Initial array length:", capacity, "| Final length:",
len(hashSet._array))
print("Time taken for all add(): ", elapsedTimeTotal)
def test_union(self):
hs = HashSet(['one', 'fish', 'two', 'fish'])
hs2 = HashSet(['red', 'fish', 'blue', 'fish'])
hs_union = hs.union(hs2)
assert hs_union.contains('red') is True
assert hs_union.contains('blue') is True
print(str(hs_union))
assert hs_union.contains('purple') is False
def test_init(self):
hs = HashSet()
assert hs.size == 0
# Test elements with given sequence
elements = [0, 1, 2, 1, 0]
hs = HashSet(elements)
assert hs.size == 3
assert str(hs) == '{0, 1, 2}'
def test_difference(self):
first_set = HashSet(['One', 'Two', 'Three', 'Four'])
second_set = HashSet(['Red', 'Two', 'Three', 'Orange'])
difference = first_set.difference(second_set)
print(difference.size)
assert difference.contains('One') == True
assert difference.contains('Two') == False
assert difference.contains('Three') == False
def test_intersection(self):
data_a = ['A', 'B', 'C', 'D']
hs_a = HashSet(data_a)
data_b = ['C', 'D', 'E', 'F']
hs_b = HashSet(data_b)
intersection_hs = hs_a.intersection(hs_b)
assert intersection_hs.contains('C') == True
assert intersection_hs.contains('D') == True
def test_difference(self):
data_a = ['A', 'B', 'C', 'D']
hs_a = HashSet(data_a)
data_b = ['C', 'D', 'E', 'F']
hs_b = HashSet(data_b)
difference_set = hs_a.difference(hs_b)
assert difference_set.contains('A') == True
assert difference_set.contains('B') == True
def test_intersection(self):
hs = HashSet(['one', 'fish', 'two', 'fish'])
hs2 = HashSet(['red', 'fish', 'blue', 'fish', 'two'])
hs_intersect = hs.intersection(hs2)
assert hs_intersect.contains('fish') is True
assert hs_intersect.contains('two') is True
print(str(hs_intersect))
assert hs_intersect.contains('one') is False
assert hs_intersect.contains('red') is False
assert hs_intersect.contains('blue') is False
def test_difference(self):
hs = HashSet(['one', 'fish', 'two', 'fish'])
hs2 = HashSet(['red', 'fish', 'blue', 'fish', 'two'])
hs_difference = hs.difference(hs2)
assert hs_difference.contains('red') is True
assert hs_difference.contains('blue') is True
assert hs_difference.contains('one') is True
print(str(hs_difference))
assert hs_difference.contains('fish') is False
assert hs_difference.contains('two') is False
def test_union(self):
first_set = HashSet(['One', 'Two', 'Three', 'Four'])
second_set = HashSet(['Red', 'Green', 'Blue'])
union = first_set.union(second_set)
assert union.size == 7
assert union.contains('Two') == True
assert union.contains('Three') == True
assert union.contains('Blue') == True
assert union.contains('Purple') == False
assert union.contains('Six') == False
class HashMap:
class __KVPair:
def __init__(self, key, value):
self.key = key
self.value = value
def __eq__(self, other):
if type(self) != type(other):
return False
return self.key == other.key
def get_key(self):
return self.key
def get_value(self):
return self.value
def __hash__(self):
return hash(self.key)
def __init__(self):
self.hash_set = HashSet()
def __len__(self):
return len(self.hash_set)
def __contains__(self, item):
return HashMap.__KVPair(item, None) in self.hash_set
def not__contains__(self, item):
return item not in self.hash_set
def __setitem__(self, key, value):
self.hash_set.add(HashMap.__KVPair(key, value))
def __getitem__(self, key):
if HashMap.__KVPair(key, None) in self.hash_set:
return self.hash_set[HashMap.__KVPair(key, None)].get_value()
raise KeyError(f"Key '{key}' not in HashMap")
def __iter__(self):
for i in self.hash_set:
yield i.get_key()
def __str__(self):
s = "{"
items = []
for i in self.hash_set:
items.append(f"{repr(i.get_key())}: {repr(i.get_value())}")
s += ", ".join(items)
s += "}"
return s
def __repr__(self):
return str(self)
def test_add_twice_and_contains(self):
hs = HashSet()
hs.add('I')
hs.add('V')
hs.add('X')
assert hs.size == 3
hs.add('V') # Update value
hs.add('X') # Update value
assert hs.contains('I') is True
assert hs.contains('V') is True
assert hs.contains('X') is True
assert hs.size == 3 # Check size is not overcounting
def form_puzzle(matrix):
rows = len(matrix)
cols = len(matrix[0])
for row in range(rows):
for col in range(cols):
if matrix[row][col] == "x":
matrix[row][col] = HashSet([1,2,3,4,5,6,7,8,9])
else:
matrix[row][col] = HashSet([matrix[row][col]])
return matrix
def test_add(self):
hs = HashSet([1, 3, 5, 7]) # size 4
assert hs.contains(23) == False
hs.add(23) #size 5
assert hs.contains(23) == True
hs.add(2) #size 6
assert hs.size == 6
def test_is_subset(self):
elements1 = ["1", "4", "6"]
elements2 = ["1", "4"]
hs = HashSet(elements1)
other_hs = HashSet(elements2)
assert other_hs.is_subset(hs) == True
assert hs.is_subset(other_hs) == False
other_hs.add("7")
assert other_hs.is_subset(hs) == False
def test_remove(self):
elements = ["hola", "adios", "test", "test", "annie"]
hs = HashSet(elements)
assert hs.contains("annie") == True
hs.remove("annie")
assert hs.contains("annie") == False
with self.assertRaises(ValueError):
hs.remove("pamis") # Element does not exist
def test_union(self):
elements1 = ["hola", "adios", "test", "test", "annie"]
elements2 = ["pamis", "blah", "other", "test", "hola"]
hs = HashSet(elements1)
other_hs = HashSet(elements2)
union = hs.union(other_hs)
assert union.contains("hola") == True
assert union.contains("adios") == True
assert union.contains("test") == True
assert union.contains("annie") == True
assert union.contains("pamis") == True
assert union.contains("blah") == True
assert union.contains("other") == True
def Q2(highestInteger):
"""
Parameter:
highestInteger is the max integer to add to the HashSet. 1 - highestInteger.
"""
hashSet = HashSet([], 100)
for number in range(1, highestInteger):
hashSet.add(number)
startTime = time.time()
print("3 in hashSet: ", 3 in hashSet)
endTime = time.time()
elapsedTime = round(endTime - startTime, 10)
print("Time to find 3: ", elapsedTime)
print("Array length: ", len(hashSet._array))
return hashSet
def test_intersection(self):
elements1 = ["1", "2", "5", "9"]
elements2 = ["9", "2", "4", "3"]
hs = HashSet(elements1)
other_hs = HashSet(elements2)
intersection = hs.intersection(other_hs)
assert intersection.contains("9") == True
assert intersection.contains("2") == True
assert intersection.contains("1") == False
assert intersection.contains("5") == False
assert intersection.contains("4") == False
assert intersection.contains("3") == False
def test_difference(self):
elements1 = ["1", "2", "5", "9"]
elements2 = ["9", "2", "4", "3"]
hs = HashSet(elements1)
other_hs = HashSet(elements2)
difference = hs.difference(other_hs)
assert difference.contains("1") == True
assert difference.contains("5") == True
assert difference.contains("9") == False
assert difference.contains("2") == False
assert difference.contains("4") == False
assert difference.contains("3") == False
def solve(matrix):
"""
Solve the sudoku matrix.
:param list[list[HashSet]] matrix: 2D matrix representing sudoku cells
"""
for _ in range(5):
reduce_(matrix)
if not solution_viable(matrix):
return None
if solution_ok(matrix):
return matrix
print("searching...")
for i in range(9):
for j in range(9):
if len(matrix[i][j]) > 1:
for k in matrix[i][j]:
mcopy = copy.deepcopy(matrix)
mcopy[i][j] = HashSet([k])
result = solve(mcopy)
if result is not None:
return result
return None
def test_size(self):
hs = HashSet()
assert hs.size == 0
hs.add('A')
assert hs.size == 1
hs.add('B')
assert hs.size == 2
hs.add('C')
assert hs.size == 3
def test_add(self):
elements = ["hola", "adios", "test", "test"]
hs = HashSet(elements)
hs.add("annie")
assert hs.size == 4
assert hs.contains("annie") == True
hs.add("hola")
assert hs.size == 4
assert hs.contains("hola") == True
def test_add_and_contains(self):
hs = HashSet()
hs.add('I')
hs.add('V')
hs.add('X')
assert hs.contains('I') is True
assert hs.contains('V') is True
assert hs.contains('X') is True
assert hs.size == 3
def test_contains(self):
hs = HashSet()
hs.add('I')
hs.add('V')
hs.add('X')
assert hs.contains('I') is True
assert hs.contains('V') is True
assert hs.contains('X') is True
assert hs.contains('A') is False
def test_size(self):
hs = HashSet()
assert hs.size == 0
hs.add('I')
assert hs.size == 1
hs.add('V')
assert hs.size == 2
hs.add('X')
assert hs.size == 3
