Add Python implementations for LeetCode 155 and 705

[rishigoswamy]

No description provided.

[super30admin]

Strengths:

• The solution correctly implements the HashSet operations with constant time complexity.
• The approach of using a 2D array with direct addressing is appropriate for the given constraints.
• The code is well-structured and readable, with comments explaining the approach.

Areas for Improvement:

1. Memory Efficiency: The current implementation pre-allocates all secondary arrays (1000 arrays of size 1001). This uses about 1e6 booleans, which is acceptable but not memory-efficient for small sets. Consider lazy initialization: only create a secondary array when a key is added to that primary bucket. This would reduce memory usage when the number of elements is small.
2. Redundant Calculation: The hashKeys method is called twice in each operation (add/remove/contains), which recalculates the same hashes. You can compute the hashes once and reuse them.
3. Code Clarity: The hashKeys method returns a list, which is then indexed. It might be clearer to return a tuple or simply compute both hashes in the method and use them directly without a helper function. Alternatively, you can inline the hash calculations to avoid function call overhead.

Suggested Improvements:

• For lazy initialization, in the add method, check if the secondary array for the primary index exists. If not, create it. This is similar to the reference solution in Java.
• To avoid redundant calculations, compute the primary and secondary indices once per operation and store them in local variables.

Example of improved code for add:

def add(self, key: int) -> None:
    primary = key % self.primaryArraySize
    secondary = key // self.primaryArraySize
    if self.table[primary] is None:
        # Initialize the secondary array only when needed
        self.table[primary] = [False] * self.secondaryArraySize
    self.table[primary][secondary] = True

But note: in the current student code, the entire table is pre-allocated with lists of booleans. So to implement lazy initialization, you should initialize self.table with None for each primary bucket, and then allocate the secondary array on demand.

Also, for the key 0, the secondary index is 0. For key 1000000, primary=0 and secondary=1000. So you need to ensure the secondary array for primary=0 has size 1001 (to include index 1000). For other primary buckets, the maximum secondary index is 999 (for key 999999: primary=999, secondary=999). So you can allocate size 1000 for primary buckets 1 to 999, and size 1001 for primary bucket 0. This is handled in the reference solution.

Overall, the student's solution is correct and efficient in time, but could be improved in memory usage.