
import unittest
import user_code
import ast
import re   
import unittest
import importlib

class TestTask(unittest.TestCase):
    def setUp(self):
        import user_code
        importlib.reload(user_code)
        self.HashTable = user_code.HashTable

    def test_insert_and_retrieve(self):
        ht = self.HashTable(size=4)
        ht.put("foo", 42)
        result = ht.get("foo")
        _dynamic_test(self, result == 42, "Inserted key can be retrieved.", f"Expected 42 for key 'foo', got {result}")

    def test_update_existing_key(self):
        ht = self.HashTable(size=4)
        ht.put("foo", 42)
        ht.put("foo", 99)
        result = ht.get("foo")
        _dynamic_test(self, result == 99, "Value updated for duplicate key.", f"Expected 99 after update, got {result}")

    def test_get_nonexistent_key(self):
        ht = self.HashTable(size=4)
        result = ht.get("missing")
        _dynamic_test(self, result is None, "Non-existent key returns None.", f"Expected None for missing key, got {result}")

    def test_delete_existing_key(self):
        ht = self.HashTable(size=4)
        ht.put("foo", 42)
        ht.delete("foo")
        result = ht.get("foo")
        _dynamic_test(self, result is None, "Existing key deleted.", f"Expected None after deletion, got {result}")

    def test_delete_nonexistent_key(self):
        ht = self.HashTable(size=4)
        ht.put("foo", 42)
        try:
            ht.delete("bar")
            _dynamic_test(self, True, "No error on deleting non-existent key.", "Error occurred when deleting non-existent key.")
        except Exception as e:
            _dynamic_test(self, False, "No error on deleting non-existent key.", f"Exception occurred: {e}")
        # Ensure original key still exists
        result = ht.get("foo")
        _dynamic_test(self, result == 42, "Other keys unaffected by delete of non-existent key.", f"Expected 42 for 'foo', got {result}")

    def test_collision_insert_and_retrieve(self):
        ht = self.HashTable(size=2)
        # These two keys are likely to collide in size=2
        keys = ["a", "e"]
        ht.put(keys[0], 10)
        ht.put(keys[1], 20)
        v0 = ht.get(keys[0])
        v1 = ht.get(keys[1])
        _dynamic_test(self, v0 == 10, "First colliding key retrieves correct value.", f"Expected 10 for '{keys[0]}', got {v0}")
        _dynamic_test(self, v1 == 20, "Second colliding key retrieves correct value.", f"Expected 20 for '{keys[1]}', got {v1}")

    def test_collision_delete_one_key(self):
        ht = self.HashTable(size=2)
        keys = ["a", "e"]
        ht.put(keys[0], 10)
        ht.put(keys[1], 20)
        ht.delete(keys[0])
        v0 = ht.get(keys[0])
        v1 = ht.get(keys[1])
        _dynamic_test(self, v0 is None, "Deleted key in collision bucket returns None.", f"Expected None for '{keys[0]}' after delete, got {v0}")
        _dynamic_test(self, v1 == 20, "Other colliding key remains after delete.", f"Expected 20 for '{keys[1]}', got {v1}")

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

A comprehensive course exploring the foundational algorithms and data structures that underpin modern data engineering and large-scale data systems. Learn how sorting, hashing, indexing, and probabilistic structures power real-world data infrastructure, with conceptual explanations and practical Python demonstrations.

Explore the essential algorithms for processing and organizing data efficiently, including sorting, hashing, and key-value lookup structures, with practical Python demonstrations.

Examine the tree-based and heap-based data structures that power fast search, indexing, and data organization in modern storage engines.

Delve into memory-efficient, approximate data structures and algorithms for high-throughput, streaming, and big-data scenarios.

Challenge: Implement a Custom Hash Table

Required Behavior

Chaining Requirements

Solution

Challenge: Implement a Custom Hash Table

Required Behavior

Chaining Requirements

Solution