def test_word_file():
ht = HashTable()
for word in words:
ht.set(word, word)
assert ht.get(words[654]) == words[654]
assert ht.get(words[3541]) == words[3541]
assert ht.get(words[6541]) == words[6541]
def test_collisions():
h = HashTable()
h.add(25, "foo")
h.add(125, "bar")
assert len(h.data[25]) == 2
assert h.get(25) == "foo"
assert h.get(125) == "bar"
def test_word_file():
ht = HashTable()
for word in words:
ht.set(word, word)
assert ht.get(words[654]) == words[654]
assert ht.get(words[3541]) == words[3541]
assert ht.get(words[6541]) == words[6541]
def test_same_keys_on_both_hts():
ramon = HashTable()
ramon.set('sup', 'yo')
mendoza = HashTable()
mendoza.set('sup', 'cya')
assert ramon.get('sup') == ['yo']
LJ(ramon, mendoza)
assert ramon.get('sup') == ['cya', 'yo']
def test_ht_get():
"""This tests to see that the value we input gets retrieved from the
get method"""
ramon = HT()
ramon.set('ramon', 1)
assert ramon.get('ramon') == [1]
ramon.set('mendoza', 2)
assert ramon.get('mendoza') == [2]
def test_put(self):
hash_table = HashTable()
hash_table.put('key', 2)
self.assertEqual(2, hash_table.get('key'))
self.assertEqual(1, hash_table.size())
hash_table.put('key2', 3)
self.assertEqual(3, hash_table.get('key2'))
self.assertEqual(2, hash_table.size())
def answer(arr, k):
table = HashTable(1000003)
for i in range(len(arr)):
for j in range(i + 1, len(arr)):
pair = table.get(k - arr[i] - arr[j])
if pair is not None:
if i not in pair and j not in pair:
return (arr[i], arr[j]) + table.get(k - arr[i] - arr[j])
table.insert(arr[i] + arr[j], (arr[i], arr[j]))
return None
def test_multiple_tables():
ht1 = HashTable()
ht2 = HashTable()
ht1.set('coffee', 'coffee')
ht1.set('eggs', 'eggs')
ht2.set('bacon', 'bacon')
with pytest.raises(KeyError):
ht1.get('bacon')
with pytest.raises(KeyError):
ht2.get('coffee')
def test_get(self):
table = HashTable()
self.assertRaises(Exception, table.get, None)
new_entry = table.insert('key', 'value')
self.assertEqual(new_entry, None)
self.assertTrue(table.get('key'), 'value')
new_entry = table.insert('key', 'new_value')
self.assertEqual(new_entry, 'value')
self.assertTrue(table.get('key'), 'new_value')
def test_different_keys_on_both_hts():
ramon = HashTable()
ramon.set('sup', 'yo')
mendoza = HashTable()
mendoza.set('eat', 'vomit')
assert ramon.get('sup') == ['yo']
assert mendoza.get('eat') == ['vomit']
LJ(ramon, mendoza)
assert ramon.get('sup') == [None, 'yo']
assert ramon.get('eat') == [None, 'vomit']
def test_multiple_tables():
ht1 = HashTable()
ht2 = HashTable()
ht1.set('coffee', 'coffee')
ht1.set('eggs', 'eggs')
ht2.set('bacon', 'bacon')
with pytest.raises(KeyError):
ht1.get('bacon')
with pytest.raises(KeyError):
ht2.get('coffee')
def test_end_to_end(self):
hash_table = HashTable(10)
print("Test: get on an empty hash table index")
assert_equal(hash_table.get(0), None)
print("Test: set on an empty hash table index")
hash_table.set(0, 'foo')
assert_equal(hash_table.get(0), 'foo')
hash_table.set(1, 'bar')
assert_equal(hash_table.get(1), 'bar')
print("Test: set on a non empty hash table index")
hash_table.set(10, 'foo2')
assert_equal(hash_table.get(0), 'foo')
assert_equal(hash_table.get(10), 'foo2')
print("Test: set on a key that already exists")
hash_table.set(10, 'foo3')
assert_equal(hash_table.get(0), 'foo')
assert_equal(hash_table.get(10), 'foo3')
print("Test: remove on a key that already exists")
hash_table.remove(10)
assert_equal(hash_table.get(0), 'foo')
assert_equal(hash_table.get(10), None)
print("Test: remove on a key that doesn't exist")
hash_table.remove(-1)
print('Success: test_end_to_end')
def test_get_conflict(self):
h = HashTable(30)
h.set('hi', 'HI')
h.set('w', 'W')
assert h.hash('w') == h.hash('hi')
actual1 = h.get('hi')
expected1 = 'HI'
assert actual1 == expected1
actual2 = h.get('w')
expected2 = 'W'
assert actual2 == expected2
def test_set_and_get(self):
ht = HashTable()
ht.set('I', 1)
ht.set('V', 5)
ht.set('X', 10)
assert ht.get('I') == 1
assert ht.get('V') == 5
assert ht.get('X') == 10
assert ht.length() == 3
with self.assertRaises(KeyError):
ht.get('A') # Key does not exist
def test_edge(self):
hash_table = HashTable()
hash_table.put(0, 12)
self.assertEqual(hash_table.get(0), 12)
hash_table.put(99991, 13)
self.assertEqual(hash_table.get(99991), 13)
hash_table.delete(99991)
hash_table.delete(0)
hash_table.delete(99991)
hash_table.delete(0)
self.assertEqual(hash_table.get(99991), None)
self.assertEqual(hash_table.get(0), None)
def test_set_twice_and_get(self):
ht = HashTable()
ht.set('I', 1)
ht.set('V', 4)
ht.set('X', 9)
assert ht.length() == 3
ht.set('V', 5) # Update value
ht.set('X', 10) # Update value
assert ht.get('I') == 1
assert ht.get('V') == 5
assert ht.get('X') == 10
assert ht.length() == 3 # Check length is not overcounting
def test_get():
ht = HashTable()
ht.put("James Bond", 982268945)
ht.put("Jon Snow", 981275678)
ht.put("Princess Zelda", 987651123)
ht.put("Carmen Sandiego", 981112365)
ht.put("Link the Hero", 981112345)
ht.put("Tingle the green", 987652234)
ht.put("Kin the golden", 36424852)
assert (ht.get("Kin the golden") == 36424852)
assert (ht.get("Link the Hero") == 981112345)
assert (ht.get("Zant Usurper King") == None)
assert (ht.get("Zant Usurper King", -1) == -1)
def test_hash_table(self):
hash_table = HashTable(3)
hash_table.add("key1", "val1")
hash_table.add("key2", "val2")
hash_table.add("key3", "val3")
hash_table.add("", "val_blank")
hash_table.add("key_none", None)
hash_table.delete("key2")
self.assertEqual("val1", hash_table.get("key1"))
self.assertEqual("val_blank", hash_table.get(""))
self.assertIsNone(hash_table.get("key_none"))
self.assertIsNone(hash_table.get("key2"))
self.assertIsNone(hash_table.get("hoge"))
self.assertRaises(Exception, hash_table.get, None)
def test_simple(self, size, raw, removes):
h = HashTable(size) if size else HashTable()
for k, v in raw.items():
h.put(k, v)
self.assertEqual(len(raw), h.size)
for k, v in raw.items():
self.assertEqual(v, h.get(k))
for k in removes:
h.remove(k)
del raw[k]
self.assertEqual(len(raw), h.size)
self.assertEqual(raw.get(k), h.get(k))
class SymbolTable:
def __init__(self):
self.table = HashTable()
self.checkingTable = {}
def add(self, new_entry):
entry = self.checkingTable.get(new_entry.get_key())
if entry is None:
self.checkingTable[new_entry.get_key()] = new_entry.get_value()
self.table.add(new_entry.get_key(), new_entry.get_value())
else:
if isinstance(new_entry, Identifier):
self.table.add(new_entry.get_key(), new_entry.get_value())
return new_entry.get_key()
def get(self, key):
return self.table.get(key)
def get_table(self):
return self.table.items()
def __str__(self):
return str(self.table.items())
def print_symbol_table(self):
for key in self.table.items():
value = self.table.items()[key]
print("{ ID:", value[0], ", Value:", value[1], "}")
class TestHashTable(unittest.TestCase):
def setUp(self):
self.hash_table = HashTable()
def testPutGet(self):
self.hash_table.put('August', 8)
self.assertEqual(self.hash_table.get('August'), 8)
def testRaiseKeyError(self):
with self.assertRaises(KeyError):
self.hash_table.get('May')
def testRaiseHashingError(self):
self.hash_table.table[800] = ('aju', 13)
with self.assertRaises(KeyError):
self.hash_table.get('txt')
def test_set_returns_key():
"""Test get returns the key."""
from hash_table import HashTable
h = HashTable(11)
h.set('jackie', 'robinson')
h.set('jackie', 'murray')
assert h.get('jackie') == 'murray'
def test_replace(self):
hash_table = HashTable()
key = 'key'
hash_table.put(key, 2)
hash_table.put(key, 3)
self.assertEqual(3, hash_table.get(key))
self.assertEqual(1, hash_table.size())
def test_remove(self):
hash_table = HashTable()
hash_table.put('key', 2)
hash_table.put('key1', 3)
hash_table.remove('key')
self.assertEqual(1, hash_table.size())
self.assertEqual(None, hash_table.get('key'))
class HashTableTest(TestCase):
def setUp(self):
self.hash_table = HashTable(3)
def test_insert(self):
self.hash_table.insert("1", 1)
self.assertEqual(self.hash_table.get("1"), 1)
def test_get(self):
self.hash_table.insert("1", 1)
self.assertEqual(self.hash_table.get("1"), 1)
def test_delete(self):
self.hash_table.insert("1", 1)
self.hash_table.delete("1")
self.assertEqual(self.hash_table.get("1"), None)
def test_get():
one = HashTable()
one.add('fond','enamored')
one.add('wrath', 'anger')
one.add('diligent', 'employed')
one.add('outfit', 'garb')
one.add('guide', 'usher')
assert one.get('fond') == 'enamored'
def get_distances(locations):
"""
Complexity: Big O(N^2)
Get all the distances from the csv file and create a distances hashtable
We will use the hash table later to compute the distance from one location to another
"""
distances = HashTable()
with open("./data/distance.csv") as csv_file:
csv_reader = csv.reader(csv_file)
for rowIndex, row in enumerate(csv_reader):
distances.set(locations[rowIndex].address, HashTable())
for distanceIndex, distance in enumerate(row):
if distance != "" and distance != "0.0":
if distances.get(locations[rowIndex].address) is None:
distances.set(locations[rowIndex].address, HashTable())
inner_hash = distances.get(locations[rowIndex].address)
inner_hash.set(locations[distanceIndex].address,
float(distance))
return distances
def test_hash_on_word_list():
"""Test that hash works on a giant list of words."""
from hash_table import HashTable
import io
new_hash = HashTable(500)
file = io.open('/usr/share/dict/words')
for i in range(250000):
key = value = file.readline()
new_hash.set(key, value)
assert new_hash.get(key) == value
class HashTableTest(TestCase):
def setUp(self) -> None:
self.hash_table = HashTable()
def test_attributes(self):
self.assertEqual(4, len(self.hash_table.keys))
self.assertEqual(4, len(self.hash_table.values))
self.assertEqual(4, self.hash_table.capacity)
def test_with_available_space(self):
self.hash_table.add("Bobby", "5")
self.assertEqual(1, self.hash_table.actual_length)
self.assertEqual(4, self.hash_table.capacity)
self.assertEqual("5", self.hash_table["Bobby"])
def test_without_available_space_increase_size(self):
for number in range(1, self.hash_table.capacity + 1):
self.hash_table.add(f"test_{number}", f"value_{number}")
self.assertEqual(4, self.hash_table.actual_length)
self.assertEqual(4, self.hash_table.capacity)
self.hash_table.add("test_5", "value_5")
self.assertEqual(5, self.hash_table.actual_length)
self.assertEqual(8, self.hash_table.capacity)
self.assertIn("test_5", self.hash_table.keys)
def test_value_replaced_if_key_exist(self):
self.hash_table.add("Bobby", "5")
self.assertEqual("5", self.hash_table["Bobby"])
self.hash_table["Bobby"] = "6"
self.assertEqual("6", self.hash_table["Bobby"])
def test_get_existing_key(self):
self.hash_table.add("Bobby", "5")
self.assertEqual("5", self.hash_table.get("Bobby"))
def test_get_no_existing_key(self):
self.hash_table.add("Bobby", "5")
self.assertIsNone(self.hash_table.get("B"))
def test_representation(self):
self.hash_table.add("Bobby", "5")
self.assertEqual("{Bobby: 5}", str(self.hash_table))
def test_many(self):
words = [line.strip() for line in open('/usr/share/dict/words')]
words = words[:300]
len_words = len(words)
h = HashTable(len_words)
for word in words:
h.set(word, word)
for l in h.hlist:
print len(l)
for word in words:
assert h.get(word) == word
def repeated_word(lengthy_string):
"""Return the first repeated word of an lengthy input string."""
lengthy_string = lengthy_string.lower()
lengthy_list = lengthy_string.split(' ')
ht = HashTable(len(lengthy_list))
for word in lengthy_list:
if ht.get(word):
return word
else:
ht.set(word, word)
return False
def test_table_collision():
"Tests the collision"
obj = HashTable(size=1000)
random_keys = []
for i in range(2000):
random_key = ''.join(random.sample(string.ascii_lowercase, 10))
random_keys.append(random_key)
obj.set(random_key, i)
for i, random_key in enumerate(random_keys):
assert obj.get(random_key) == i
def repeated_word(string):
"""Return first repeated word."""
try:
all_words = string.lower().split(' ')
except TypeError:
raise TypeError
ht = HT()
for each in all_words:
found = ht.get(each)
if found:
return each
ht.set(each, each)
def test_naive_hash_causes_many_collisions():
"""Tests if naive hash causes multiple collisions."""
from hash_table import HashTable
hash_table = HashTable(hash_function='naive')
equal = True
while equal:
sample_words = random.sample(list_words, 50)
for word in sample_words:
hash_table.set(word, word)
hash_table_words = [hash_table.get(word) for word in sample_words]
equal = hash_table_words == sample_words
assert not equal
def test():
htb = HashTable()
htb.set('I', 1)
htb.set('V', 5)
htb.set('X', 10)
htb.set('L', 50)
htb.set('C', 100)
htb.set('D', 500)
htb.set('M', 1000)
print(htb.get('I') == 1)
print(htb.get('V') == 5)
print(htb.get('X') == 10)
print(htb.get('L') == 50)
print(htb.get('C') == 100)
print(htb.get('D') == 500)
print(htb.get('M') == 1000)
print(htb.get('foo') == None)
htb.update('V', 2)
print(htb.get('V') == 2)
print("count: {}".format(htb.count()))
print("keys: {}".format(htb.keys()))
print("values: {}".format(htb.values()))
print("to_list: {}".format(htb.to_list()))
def test():
htb = HashTable()
htb.set('I', 1)
htb.set('V', 5)
htb.set('X', 10)
htb.set('L', 50)
htb.set('C', 100)
htb.set('D', 500)
htb.set('M', 1000)
print(htb.get('I') == 1)
print(htb.get('V') == 5)
print(htb.get('X') == 10)
print(htb.get('L') == 50)
print(htb.get('C') == 100)
print(htb.get('D') == 500)
print(htb.get('M') == 1000)
print(htb.get('foo') == None)
htb.update('V', 2)
print(htb.get('V') == 2)
print("count: {}".format(htb.count()))
print("keys: {}".format(htb.keys()))
print("values: {}".format(htb.values()))
print("to_list: {}".format(htb.to_list()))
def test_get():
"""Test get fucntion."""
from hash_table import HashTable
new_hash = HashTable(100)
new_hash.set('pirate', 'ninja')
assert new_hash.get('pirate') == 'ninja'
def test_replacement():
h = HashTable()
h.add(12, "foo")
h.add(12, "bar")
assert h.get(12) == "bar"
def test_insertion():
h = HashTable()
h.add(48, "teststring")
assert h.get(48) == "teststring"
def test_hash():
ht = HashTable()
ht.set('coffee', 'coffee')
assert ht.get('coffee') == 'coffee'
def test_get():
"""Test get method."""
hT = HashTable()
hT.set("test", "test")
assert hT.get("test") == "test"
def test_duplicate_hash_val():
ht = HashTable()
ht.set('bob', 'bob')
ht.set('obb', 'obb')
assert ht.get('bob') == 'bob'
assert ht.get('obb') == 'obb'
def test_non_item():
ht = HashTable()
ht.set('coffee', 'coffee')
with pytest.raises(KeyError):
ht.get('milk')
def test_big_table(word_list):
table = HashTable(4096)
[table.set(word, word) for word in word_list]
assert [table.get(word) == word for word in word_list]
for word in word_list:
print "expected: {}, seen: {}".format(word, table.get(word))
def test_get(self):
h = HashTable(30)
h.set('puppy', 'cute')
actual = h.get('puppy')
expected = 'cute'
assert actual == expected
