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_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_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_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_size(self):
hs = HashSet([5, 2, 6, 1, 3])
assert hs.size() == 5
hs.add(42)
assert hs.size() == 6
hs.add(21)
assert hs.size() == 7
hs.remove(42)
assert hs.size() == 6
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
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_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):
hs = HashSet()
hs.add('I')
hs.add('V')
hs.add('X')
assert hs.size == 3
hs.remove('I')
hs.remove('X')
assert hs.size == 1
with self.assertRaises(KeyError):
hs.remove('X') # Key no longer exists
with self.assertRaises(KeyError):
hs.remove('A') # Key does not exist
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_remove(self):
hs = HashSet()
hs.add('A')
hs.add('B')
hs.add('C')
hs.remove('A')
assert hs.contains('A') == False
assert hs.size == 2
hs.remove('C')
assert hs.contains('C') == False
assert hs.size == 1
hs.remove('B')
assert hs.contains('B') == False
assert hs.size == 0
with self.assertRaises(ValueError):
hs.remove('D') # Key never existed
hs.remove('A') # Key no longer exists
def main():
# HashSet methods testing
hset1 = HashSet([1, 2, 3, 4, 7, 8, 9, 10, 12, 15])
hset1.printChains()
print(hset1)
print("loadFactor() = ", hset1.loadFactor())
print("cellLoadFactor() = ", hset1.cellLoadFactor())
print("_" * 70)
hset1.add(9) # 9 gets added to chain
hset1.add(14) # 14 triggers rehash()
hset1.add(30) # 30 gets added to front of chain
hset1.printChains()
print(hset1)
print("loadFactor() = ", hset1.loadFactor())
print("cellLoadFactor() = ", hset1.cellLoadFactor())
print("_" * 70)
# Lab Questions
print("Question 1")
print("Adding randomly:")
Q1(True, 500) # True is to randomly add integers
print("\nAdding in order:")
Q1(False, 500) #False adds the integers in order
print("\nAdding randomly:")
Q1(True, 100) # True is to randomly add integers
print("\nAdding in order:")
Q1(False, 100) #False adds the integers in order
print("_" * 70)
print("Question 2")
print("Adding 1 to 80 then find 3:")
Q2(81)
print("\nAdding 1 to n then find 3:")
Q2(161)
print("_" * 70)
print("Question 3")
print("Adding 1 to 80, remove 4 to 80, then find 3:")
Q3(81)
print("\nAdding 1 to 80, remove 4 to n, then find 3:")
Q3(161)
def test_difference(self):
"""Check if the difference operation works as intended."""
hashset = HashSet()
other_hashset = HashSet()
# Spot the difference:
hashset.add('o')
hashset.add('o')
hashset.add('o')
hashset.add('o')
other_hashset.add('O')
other_hashset.add('o')
other_hashset.add('o')
other_hashset.add('o')
other_hashset.add('o')
difference = hashset.difference(other_hashset)
assert difference.size == 1
assert difference.contains('o') is False
assert difference.contains('O') is True
def test_union(self):
"""Check if the union operation works as intended."""
hashset = HashSet()
hashset.add('FUSION!')
hashset.add('HA!')
other_hashset = HashSet()
other_hashset.add('HA!')
hashset.add('FUSION!')
union = hashset.union(other_hashset)
assert union.size == 2
assert union.contains('FUSION!') is True
assert union.contains('HA!') is True
def test_contains(self):
"""Check to see if the contains method works as intended."""
hashset = HashSet()
hashset.add('Hello')
hashset.add('are')
hashset.add('you')
hashset.add('a')
hashset.add('hashset')
assert hashset.contains('Hello') is True
assert hashset.contains('no') is False
assert hashset.contains('you') is True
assert hashset.contains('are') is True
def test_intersection(self):
"""Check if the intersection operation works as intended."""
hashset = HashSet()
hashset.add('Hash')
hashset.add('Set')
other_hashset = HashSet()
other_hashset.add('Linked')
other_hashset.add('Set')
intersection = hashset.intersection(other_hashset)
assert intersection.size == 1
assert intersection.contains('Hash') is False
assert intersection.contains('Set') is True
assert intersection.contains('Linked') is False
def test_add(self):
new_set = HashSet()
assert new_set.__length__() == 0
new_set.add('red')
new_set.add('brown')
new_set.add('gray')
assert new_set.__length__() == 3
assert new_set.contains('red') == True
assert new_set.contains('brown') == True
assert new_set.contains('purple') == False
new_set.add('orange')
new_set.add('purple')
assert new_set.__length__() == 5
assert new_set.contains('purple') == True
def test_add_and_remove(self):
elements = [1, 2, 3]
hs = HashSet(elements)
hs.add(4)
hs.add(5)
hs.add(6)
hs.add(7)
assert hs.contains(2) is True
assert hs.contains(4) is True
assert hs.contains(5) is True
assert hs.contains(6) is True
assert hs.contains(7) is True
assert hs.contains(21) is False
hs.remove(7)
assert hs.contains(7) is False
hs.remove(6)
assert hs.contains(6) is False
hs.remove(5)
assert hs.contains(5) is False
hs.remove(4)
assert hs.contains(4) is False
assert hs.size() == 3
def test_remove(self):
"""Check to see if items can be removed from the HashSet."""
hashset = HashSet()
hashset.add('Please')
hashset.add('dont')
hashset.add('remove')
hashset.add('me')
assert hashset.size == 4
hashset.remove('Please')
hashset.remove('dont')
assert hashset.size == 2
self.assertCountEqual(hashset.elements(), ['remove', 'me'])
hashset.remove('me')
assert hashset.size == 1
with self.assertRaises(KeyError):
hashset.remove('NOOOO')
class HashMap:
class __KVPair:
def __init__(self, k, v):
self.k = k
self.v = v
def __eq__(self, other):
if type(self) != type(other):
return False
return self.k == other.k
def __hash__(self):
return hash(self.k)
def __init__(self):
self.hset = HashSet()
def __len__(self):
return len(self.hset)
def __contains__(self, item):
return self.__KVPair(item, None) in self.hset
def not__contains__(self, item):
return item not in self.hset
def __setitem__(self, k, v):
self.hset.add(self.__KVPair(k, v))
def __getitem__(self, k):
if self.__KVPair(k, None) in self.hset:
return self.hset[self.__KVPair(k, None)].v
raise KeyError('key {} not in hashmap'.format(k))
def __iter__(self):
for x in self.hset:
yield x.k
def test_add(self):
hs = HashSet()
assert hs.size == 0
hs.add(2)
assert hs.size == 1
hs.add(2)
assert hs.size == 1
hs.add(3)
assert hs.size == 2
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
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_contains(self):
hs = HashSet()
hs.add(0)
hs.add(1)
hs.add('zero')
hs.add('one')
assert hs.contains(0) is True
assert hs.contains('zero') is True
assert hs.contains('0') is False
assert hs.contains(2) is False
def test_elements(self):
"""Check if a hashset of items in the HashSet can be retrieved."""
hashset = HashSet()
assert hashset.elements() == []
hashset.add('A')
assert hashset.elements() == ['A']
hashset.add('tiny')
self.assertCountEqual(hashset.elements(), ['A', 'tiny'])
hashset.add('hashset')
self.assertCountEqual(hashset.elements(), ['A', 'tiny', 'hashset'])
def test_size(self):
"""Check if the length is updated properly."""
hashset = HashSet()
assert hashset.size == 0
hashset.add('check')
assert hashset.size == 1
hashset.add('hashset')
assert hashset.size == 2
hashset.add('size')
assert hashset.size == 3
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 test_remove(self):
hs = HashSet()
assert hs.size == 0
hs.add(0)
hs.add(1)
hs.add('zero')
hs.add('one')
assert hs.size == 4
hs.remove(0)
assert hs.size == 3
hs.remove(1) == 2
hs.remove('zero') == 1
with self.assertRaises(KeyError):
hs.remove('zero')
with self.assertRaises(KeyError):
hs.remove('0')
def test_add_remove(self):
set = HashSet()
set.add('A')
assert len(set) == 1
assert set.contains('A') is True
set.add('B')
assert len(set) == 2
assert set.contains('B') is True
set.add('C')
assert len(set) == 3
assert set.contains('C') is True
set.remove('B')
assert len(set) == 2
assert set.contains('B') is False
set.remove('A')
assert len(set) == 1
assert set.contains('A') is False
set.remove('C')
assert len(set) == 0
assert set.contains('C') is False
with self.assertRaises(ValueError):
set.remove('C')
from hashset import HashSet a = HashSet([1, 2, 3, 4, 5, 4]) print(a) a.add(7) a.add(9) print(a) a.remove(1) print(a)
