def test_rehashing(self): keys = [ "first", "second", "third", "fourth", "fifth", "sixth", "seventh", "eighth", "ninth", "tenth" ] values = list(range(1, 11)) hm = HashMap() self.assertEqual(hm.size(), 0) self.assertEqual(hm.capacity(), 8) for i in range(0, 5): hm.set(keys[i], values[i]) self.assertEqual(hm.size(), 5) self.assertEqual(hm.capacity(), 8) output = hm.keys() self.assertEqual(len(output), 5) for key in output: self.assertIn(key, keys) for i in range(5, 10): hm.set(keys[i], values[i]) self.assertEqual(hm.size(), 10) self.assertEqual(hm.capacity(), 16) output = hm.keys() for key in output: self.assertIn(key, keys) for key in keys: self.assertIn(key, output)
def test_keys(): hm = HashMap() keys = [(r, r) for r in (range(10))] values = list(range(1, 11)) for k, v in zip(keys, values): hm.set(k, v) keys2 = hm.keys() keys2.sort() assert keys == keys2
class TestHashMapFunctions(unittest.TestCase): def setUp(self): self._ref = {} self._map = HashMap() def add(self, key, value): self._ref[key] = value self._map[key] = value def delete(self, key, value): del self._ref[key] del self._map[key] def test_add(self): for i in xrange(100): self.add("key_"+str(i), "value_"+str(i)) self.assert_ref_equals_map() def test_delete(self): for i in xrange(100): self.add("key_"+str(i), "value_"+str(i)) for i in xrange(0, 100, 2): self.delete("key_"+str(i), "value_"+str(i)) self.assert_ref_equals_map() def test_get(self): for i in xrange(100): self.add("key_"+str(i), "value_"+str(i)) for i in xrange(100): self.assertEqual(self._ref["key_"+str(i)], self._map["key_"+str(i)]) def test_random(self): import random for i in xrange(10000): r = random.randint(0, 2) key = "key_"+str(random.randint(0, 9)) value = "value_"+str(random.randint(0, 9)) if r == 0: self.add(key, value) elif r == 1 and self._ref.get(key, None) is not None: self.delete(key, value) else: self.assertEqual(self._ref.get(key, None), self._map.get(key, None)) def assert_ref_equals_map(self): self.assertItemsEqual(self._ref.keys(), self._map.keys()) self.assertItemsEqual(self._ref.values(), self._map.values())
def main(): ''' driver for project ''' hash_map = HashMap() with open("AliceInWonderland.txt", encoding='utf8') as input_file: for raw_line in input_file: words = clean_line(raw_line) for word in words: hash_map.set(word, hash_map.get(word, 0) + 1) keys = hash_map.keys() key_values = [(key, hash_map.get(key)) for key in keys] key_values.sort(reverse=True, key=lambda x: x[1]) print("The most common words are:") for element in key_values[:15]: print(f'{element[0]}\t\t{element[1]}') print()
def test_ten_keys(self): hm = HashMap() keys = [ "first", "second", "third", "fourth", "fifth", "sixth", "seventh", "eighth", "ninth", "tenth" ] values = list(range(1, 11)) print(values) for i in range(len(keys)): hm.set(keys[i], values[i]) print(hm.keys()) # print(hm.get('sixth')) self.assertEqual(hm.get("sixth"), 6) self.assertNotEqual(hm.get("sixth"), 7) self.assertNotEqual(hm.get("sixth"), 5) hm.set("third", 409) self.assertEqual(hm.get("third"), 409) self.assertEqual(hm.size(), 10) self.assertEqual(hm.capacity(), 16)
class Distance: def __init__(self): self.address = HashMap() self.distance = [] self.address_manager = [] self.combo = {} def add_address(self, address, zip_code): # Big O: O(1) # inserts address into address list self.address.insert(address, zip_code) def print_addresses(self): # Big O: O(1) # keys to address list self.address.keys() def add_distance(self, distance): # Big O: O(1) # appends distance to list self.distance.append(distance) def combine(self): # Big O: O(N^2) # combines the two separate lists (addresses and distances) # into a usable dictionary keys = self.address.keys() distances = self.distance for i in keys: for j in distances: if i in j: del j[0] self.combo[i] = j return self.combo def distances_from_address(self, address): # Big O: O(1) # return all distances from address return self.combo[address] def distance_to_specific(self, address_a, index_b): # Big O: O(1) # Retrieve the distance between two addresses return float(self.combo[address_a][index_b - 1]) def manage_address(self, address): # Big O: O(1) # appends address to an address list self.address_manager.append(address) return self.address_manager def index_to_address(self, index): # Big O: O(1) # finds the address associated with an index return self.address_manager[index] def address_to_index(self, address): # Big O: O(N) index_number = 0 for i in self.address_manager: index_number += 1 if i == address: return index_number def closest_neighbor(self, address): # Big O: O(N) # return index # of closest distance testing = [] for i in self.combo[address]: testing.append(float(i)) m = min(i for i in testing if i > 0) min_index = testing.index(m) closest = self.index_to_address(min_index) print('Between {} and {} is {}'.format(address, closest, m)) def distance_traveled(self, time, list): # Big O: O(N) # calculates the distances between each address in the list # returns the distances in list form a = list distance_between = [] for i, nexti in zip(a, a[1::]): next_index = self.address_to_index(nexti) distance_between.append(self.distance_to_specific(i, next_index)) return distance_between def load_distances(self, node_list, combo, distances): # Big O: O(N) # read files, sets up addresses and distances between each address with open(node_list) as set_address: for line in set_address: line = line.strip().split('\t') distances.add_address(line[0], line) distances.manage_address(line[0]) with open(combo) as set_distance: for line in set_distance: split = line.strip().split('\t') distances.add_distance(split) distances.combine()
from hashmap import HashMap # Utilizing hashmap class hash_map = HashMap() print("Initializing empty hashmap " + str(hash_map)) hash_map["FirstKey"] = 23 hash_map["SecondKey"] = 53 print("Adding two values to hashmap " + str(hash_map)) hash_map["FirstKey"] = 13 print("Updating first value in hashmap " + str(hash_map)) hash_map.delete("FirstKey") print("Deleting value in hashmap " + str(hash_map)) hash_map_two = HashMap() hash_map_two["FirstKey"] = 203 print("Initializing second hashmap " + str(hash_map_two)) hash_map.update(hash_map_two) print("Updating first hashmap with second hashmap " + str(hash_map)) print("All keys in hashamp " + str(hash_map.keys())) print("All values in hashmap " + str(hash_map.values())) print("The amount of buckets in hashmap " + str(hash_map.num_sections()))