Fix testing indentation

This commit is contained in:
Andrew Scott 2022-06-25 13:50:01 -04:00
parent bd89c86984
commit 155571e227
Signed by: a
GPG key ID: 3EB62D0BBB8DB381

View file

@ -1,11 +1,8 @@
# Name: Andrew Scott # Author: Andrew Scott
# OSU Email: scottand@oregonstate.edu # Description: HashMap implementation using Separate Chaining for collision
# Course: CS261 - Data Structures # resolution
# Assignment: 6
# Due Date: 2022-06-03
# Description: HashMap implementation using Separate Chaining
from a6_include import ( from hm_include import (
DynamicArray, DynamicArray,
LinkedList, LinkedList,
SLNode, SLNode,
@ -15,12 +12,19 @@ from a6_include import (
class HashMap: class HashMap:
"""
Hash map that uses separate chaining for colision resolution
Parameters
----------
capacity : int
Initial capacity for the hash map
function : function
Hash function to use
"""
def __init__(self, capacity: int, function) -> None: def __init__(self, capacity: int, function) -> None:
""" """Constructor for the HashMap class"""
Initialize new HashMap that uses
separate chaining for collision resolution
DO NOT CHANGE THIS METHOD IN ANY WAY
"""
self._buckets = DynamicArray() self._buckets = DynamicArray()
for _ in range(capacity): for _ in range(capacity):
self._buckets.append(LinkedList()) self._buckets.append(LinkedList())
@ -30,30 +34,40 @@ class HashMap:
self._size = 0 self._size = 0
def __str__(self) -> str: def __str__(self) -> str:
"""Override string method to provide more readable output
Returns
-------
str
Hash map in human readable form
""" """
Override string method to provide more readable output
DO NOT CHANGE THIS METHOD IN ANY WAY
"""
out = "" out = ""
for i in range(self._buckets.length()): for i in range(self._buckets.length()):
out += str(i) + ": " + str(self._buckets[i]) + "\n" out += str(i) + ": " + str(self._buckets[i]) + "\n"
return out return out
def get_size(self) -> int: def get_size(self) -> int:
"""Get the map size
Returns
-------
int
Size of the hash map
""" """
Return size of map
DO NOT CHANGE THIS METHOD IN ANY WAY
"""
return self._size return self._size
def get_capacity(self) -> int: def get_capacity(self) -> int:
""" """Get the map capacity
Return capacity of map
DO NOT CHANGE THIS METHOD IN ANY WAY
"""
return self._capacity
# ------------------------------------------------------------------ # Returns
-------
int
Capacity of the hash map
"""
return self._capacity
def put(self, key: str, value: object) -> None: def put(self, key: str, value: object) -> None:
"""Adds (or updates) a key/value pair to the hash map """Adds (or updates) a key/value pair to the hash map
@ -280,223 +294,224 @@ def find_mode(da: DynamicArray) -> (DynamicArray, int):
# ------------------- BASIC TESTING ---------------------------------------- # # ------------------- BASIC TESTING ---------------------------------------- #
if __name__ == "__main__":
print("\nPDF - put example 1") if __name__ == "__main__":
print("-------------------")
m = HashMap(50, hash_function_1)
for i in range(150):
m.put("str" + str(i), i * 100)
if i % 25 == 24:
print(m.empty_buckets(), m.table_load(), m.get_size(), m.get_capacity())
print("\nPDF - put example 2") print("\nPDF - put example 1")
print("-------------------") print("-------------------")
m = HashMap(40, hash_function_2) m = HashMap(50, hash_function_1)
for i in range(50): for i in range(150):
m.put("str" + str(i // 3), i * 100) m.put("str" + str(i), i * 100)
if i % 10 == 9: if i % 25 == 24:
print(m.empty_buckets(), m.table_load(), m.get_size(), m.get_capacity()) print(m.empty_buckets(), m.table_load(), m.get_size(), m.get_capacity())
print("\nPDF - empty_buckets example 1") print("\nPDF - put example 2")
print("-----------------------------") print("-------------------")
m = HashMap(100, hash_function_1) m = HashMap(40, hash_function_2)
print(m.empty_buckets(), m.get_size(), m.get_capacity()) for i in range(50):
m.put("key1", 10) m.put("str" + str(i // 3), i * 100)
print(m.empty_buckets(), m.get_size(), m.get_capacity()) if i % 10 == 9:
m.put("key2", 20) print(m.empty_buckets(), m.table_load(), m.get_size(), m.get_capacity())
print(m.empty_buckets(), m.get_size(), m.get_capacity())
m.put("key1", 30)
print(m.empty_buckets(), m.get_size(), m.get_capacity())
m.put("key4", 40)
print(m.empty_buckets(), m.get_size(), m.get_capacity())
print("\nPDF - empty_buckets example 2") print("\nPDF - empty_buckets example 1")
print("-----------------------------") print("-----------------------------")
m = HashMap(50, hash_function_1) m = HashMap(100, hash_function_1)
for i in range(150): print(m.empty_buckets(), m.get_size(), m.get_capacity())
m.put("key" + str(i), i * 100) m.put("key1", 10)
if i % 30 == 0: print(m.empty_buckets(), m.get_size(), m.get_capacity())
print(m.empty_buckets(), m.get_size(), m.get_capacity()) m.put("key2", 20)
print(m.empty_buckets(), m.get_size(), m.get_capacity())
m.put("key1", 30)
print(m.empty_buckets(), m.get_size(), m.get_capacity())
m.put("key4", 40)
print(m.empty_buckets(), m.get_size(), m.get_capacity())
print("\nPDF - table_load example 1") print("\n empty_buckets example 2")
print("--------------------------") print("-----------------------------")
m = HashMap(100, hash_function_1) m = HashMap(50, hash_function_1)
print(m.table_load()) for i in range(150):
m.put("key1", 10) m.put("key" + str(i), i * 100)
print(m.table_load()) if i % 30 == 0:
m.put("key2", 20) print(m.empty_buckets(), m.get_size(), m.get_capacity())
print(m.table_load())
m.put("key1", 30)
print(m.table_load())
print("\nPDF - table_load example 2") print("\n table_load example 1")
print("--------------------------") print("--------------------------")
m = HashMap(50, hash_function_1) m = HashMap(100, hash_function_1)
for i in range(50): print(m.table_load())
m.put("key" + str(i), i * 100) m.put("key1", 10)
if i % 10 == 0: print(m.table_load())
print(m.table_load(), m.get_size(), m.get_capacity()) m.put("key2", 20)
print(m.table_load())
m.put("key1", 30)
print(m.table_load())
print("\nPDF - clear example 1") print("\n table_load example 2")
print("---------------------") print("--------------------------")
m = HashMap(100, hash_function_1) m = HashMap(50, hash_function_1)
print(m.get_size(), m.get_capacity()) for i in range(50):
m.put("key1", 10) m.put("key" + str(i), i * 100)
m.put("key2", 20) if i % 10 == 0:
m.put("key1", 30) print(m.table_load(), m.get_size(), m.get_capacity())
print(m.get_size(), m.get_capacity())
m.clear()
print(m.get_size(), m.get_capacity())
print("\nPDF - clear example 2") print("\n clear example 1")
print("---------------------") print("---------------------")
m = HashMap(50, hash_function_1) m = HashMap(100, hash_function_1)
print(m.get_size(), m.get_capacity()) print(m.get_size(), m.get_capacity())
m.put("key1", 10) m.put("key1", 10)
print(m.get_size(), m.get_capacity()) m.put("key2", 20)
m.put("key2", 20) m.put("key1", 30)
print(m.get_size(), m.get_capacity()) print(m.get_size(), m.get_capacity())
m.resize_table(100) m.clear()
print(m.get_size(), m.get_capacity()) print(m.get_size(), m.get_capacity())
m.clear()
print(m.get_size(), m.get_capacity())
print("\nPDF - resize example 1") print("\n clear example 2")
print("----------------------") print("---------------------")
m = HashMap(20, hash_function_1) m = HashMap(50, hash_function_1)
m.put("key1", 10) print(m.get_size(), m.get_capacity())
print(m.get_size(), m.get_capacity(), m.get("key1"), m.contains_key("key1")) m.put("key1", 10)
m.resize_table(30) print(m.get_size(), m.get_capacity())
print(m.get_size(), m.get_capacity(), m.get("key1"), m.contains_key("key1")) m.put("key2", 20)
print(m.get_size(), m.get_capacity())
m.resize_table(100)
print(m.get_size(), m.get_capacity())
m.clear()
print(m.get_size(), m.get_capacity())
print("\nPDF - resize example 2") print("\n resize example 1")
print("----------------------") print("----------------------")
m = HashMap(75, hash_function_2) m = HashMap(20, hash_function_1)
keys = [i for i in range(1, 1000, 13)] m.put("key1", 10)
for key in keys: print(m.get_size(), m.get_capacity(), m.get("key1"), m.contains_key("key1"))
m.put(str(key), key * 42) m.resize_table(30)
print(m.get_size(), m.get_capacity()) print(m.get_size(), m.get_capacity(), m.get("key1"), m.contains_key("key1"))
for capacity in range(111, 1000, 117): print("\n resize example 2")
m.resize_table(capacity) print("----------------------")
m = HashMap(75, hash_function_2)
keys = [i for i in range(1, 1000, 13)]
for key in keys:
m.put(str(key), key * 42)
print(m.get_size(), m.get_capacity())
m.put("some key", "some value") for capacity in range(111, 1000, 117):
result = m.contains_key("some key") m.resize_table(capacity)
m.remove("some key")
for key in keys: m.put("some key", "some value")
# all inserted keys must be present result = m.contains_key("some key")
result &= m.contains_key(str(key)) m.remove("some key")
# NOT inserted keys must be absent
result &= not m.contains_key(str(key + 1))
print(
capacity,
result,
m.get_size(),
m.get_capacity(),
round(m.table_load(), 2),
)
print("\nPDF - get example 1")
print("-------------------")
m = HashMap(30, hash_function_1)
print(m.get("key"))
m.put("key1", 10)
print(m.get("key1"))
print("\nPDF - get example 2")
print("-------------------")
m = HashMap(150, hash_function_2)
for i in range(200, 300, 7):
m.put(str(i), i * 10)
print(m.get_size(), m.get_capacity())
for i in range(200, 300, 21):
print(i, m.get(str(i)), m.get(str(i)) == i * 10)
print(i + 1, m.get(str(i + 1)), m.get(str(i + 1)) == (i + 1) * 10)
print("\nPDF - contains_key example 1")
print("----------------------------")
m = HashMap(10, hash_function_1)
print(m.contains_key("key1"))
m.put("key1", 10)
m.put("key2", 20)
m.put("key3", 30)
print(m.contains_key("key1"))
print(m.contains_key("key4"))
print(m.contains_key("key2"))
print(m.contains_key("key3"))
m.remove("key3")
print(m.contains_key("key3"))
print("\nPDF - contains_key example 2")
print("----------------------------")
m = HashMap(75, hash_function_2)
keys = [i for i in range(1, 1000, 20)]
for key in keys:
m.put(str(key), key * 42)
print(m.get_size(), m.get_capacity())
result = True
for key in keys: for key in keys:
# all inserted keys must be present # all inserted keys must be present
result &= m.contains_key(str(key)) result &= m.contains_key(str(key))
# NOT inserted keys must be absent # NOT inserted keys must be absent
result &= not m.contains_key(str(key + 1)) result &= not m.contains_key(str(key + 1))
print(result) print(
capacity,
print("\nPDF - remove example 1") result,
print("----------------------") m.get_size(),
m = HashMap(50, hash_function_1) m.get_capacity(),
print(m.get("key1")) round(m.table_load(), 2),
m.put("key1", 10)
print(m.get("key1"))
m.remove("key1")
print(m.get("key1"))
m.remove("key4")
print("\nPDF - get_keys example 1")
print("------------------------")
m = HashMap(10, hash_function_2)
for i in range(100, 200, 10):
m.put(str(i), str(i * 10))
print(m.get_keys())
m.resize_table(1)
print(m.get_keys())
m.put("200", "2000")
m.remove("100")
m.resize_table(2)
print(m.get_keys())
print("\nPDF - find_mode example 1")
print("-----------------------------")
da = DynamicArray(["apple", "apple", "grape", "melon", "melon", "peach"])
map = HashMap(da.length() // 3, hash_function_1)
mode, frequency = find_mode(da)
print(f"Input: {da}\nMode: {mode}, Frequency: {frequency}")
print("\nPDF - find_mode example 2")
print("-----------------------------")
test_cases = (
[
"Arch",
"Manjaro",
"Manjaro",
"Mint",
"Mint",
"Mint",
"Ubuntu",
"Ubuntu",
"Ubuntu",
"Ubuntu",
],
["one", "two", "three", "four", "five"],
["2", "4", "2", "6", "8", "4", "1", "3", "4", "5", "7", "3", "3", "2"],
) )
for case in test_cases: print("\n get example 1")
da = DynamicArray(case) print("-------------------")
map = HashMap(da.length() // 3, hash_function_2) m = HashMap(30, hash_function_1)
mode, frequency = find_mode(da) print(m.get("key"))
print(f"Input: {da}\nMode: {mode}, Frequency: {frequency}\n") m.put("key1", 10)
print(m.get("key1"))
print("\n get example 2")
print("-------------------")
m = HashMap(150, hash_function_2)
for i in range(200, 300, 7):
m.put(str(i), i * 10)
print(m.get_size(), m.get_capacity())
for i in range(200, 300, 21):
print(i, m.get(str(i)), m.get(str(i)) == i * 10)
print(i + 1, m.get(str(i + 1)), m.get(str(i + 1)) == (i + 1) * 10)
print("\n contains_key example 1")
print("----------------------------")
m = HashMap(10, hash_function_1)
print(m.contains_key("key1"))
m.put("key1", 10)
m.put("key2", 20)
m.put("key3", 30)
print(m.contains_key("key1"))
print(m.contains_key("key4"))
print(m.contains_key("key2"))
print(m.contains_key("key3"))
m.remove("key3")
print(m.contains_key("key3"))
print("\n contains_key example 2")
print("----------------------------")
m = HashMap(75, hash_function_2)
keys = [i for i in range(1, 1000, 20)]
for key in keys:
m.put(str(key), key * 42)
print(m.get_size(), m.get_capacity())
result = True
for key in keys:
# all inserted keys must be present
result &= m.contains_key(str(key))
# NOT inserted keys must be absent
result &= not m.contains_key(str(key + 1))
print(result)
print("\n remove example 1")
print("----------------------")
m = HashMap(50, hash_function_1)
print(m.get("key1"))
m.put("key1", 10)
print(m.get("key1"))
m.remove("key1")
print(m.get("key1"))
m.remove("key4")
print("\n get_keys example 1")
print("------------------------")
m = HashMap(10, hash_function_2)
for i in range(100, 200, 10):
m.put(str(i), str(i * 10))
print(m.get_keys())
m.resize_table(1)
print(m.get_keys())
m.put("200", "2000")
m.remove("100")
m.resize_table(2)
print(m.get_keys())
print("\n find_mode example 1")
print("-----------------------------")
da = DynamicArray(["apple", "apple", "grape", "melon", "melon", "peach"])
map = HashMap(da.length() // 3, hash_function_1)
mode, frequency = find_mode(da)
print(f"Input: {da}\nMode: {mode}, Frequency: {frequency}")
print("\n find_mode example 2")
print("-----------------------------")
test_cases = (
[
"Arch",
"Manjaro",
"Manjaro",
"Mint",
"Mint",
"Mint",
"Ubuntu",
"Ubuntu",
"Ubuntu",
"Ubuntu",
],
["one", "two", "three", "four", "five"],
["2", "4", "2", "6", "8", "4", "1", "3", "4", "5", "7", "3", "3", "2"],
)
for case in test_cases:
da = DynamicArray(case)
map = HashMap(da.length() // 3, hash_function_2)
mode, frequency = find_mode(da)
print(f"Input: {da}\nMode: {mode}, Frequency: {frequency}\n")