Implement Hash Map with without recursion

Question

Implement a Bloom Filter data structure that supports get and put operations in O(log n) time.

Codemia · Accepted Answer

To implement a Bloom Filter that supports 'get' and 'put' operations in O(log n) time, we must first understand what a Bloom Filter is. A Bloom Filter is a probabilistic data structure that can efficiently test whether an element is a member of a set. It is important to note that it can yield false positives but never false negatives.

The operations 'put' and 'get' will utilize multiple hash functions to set and check bits in a bit array. The challenge is to implement these operations without recursion while maintaining O(log n) complexity. Given the constraints and requirements, we can leverage a list or dynamic array to represent the bit array, and a set of hash functions to map input values to positions in this array.

1. **Initialize Data Structures**: Create a bit array and a list of hash functions. The size of the bit array should be determined based on the expected number of elements and the desired false positive rate. 
   
2. **Put Operation**: When inserting an element, compute its hash values using the predefined hash functions. For each hash value, set the corresponding bit in the bit array to 1. 
   
   Example: If we have a bit array of size 10, and the hashes for 'apple' return indices 1, 3, and 7, we would set bits[1], bits[3], and bits[7] to 1. 
   
3. **Get Operation**: To check if an element is in the filter, compute the same hash values. If all corresponding bits in the bit array are set to 1, return true; otherwise, return false. 
   
   Example: For 'banana', if the hash indices are 2, 5, and 9, and bits[2] is 0, we return false.

Below is a Python implementation of the described Bloom Filter:

```python
class BloomFilter:
    def __init__(self, size, hash_functions):
        self.size = size
        self.bit_array = [0] * size
        self.hash_functions = hash_functions

def put(self, item):
        for hash_func in self.hash_functions:
            index = hash_func(item) % self.size
            self.bit_array[index] = 1

def get(self, item):
        for hash_func in self.hash_functions:
            index = hash_func(item) % self.size
            if self.bit_array[index] == 0:
                return False
        return True
```

In this implementation, `hash_functions` could be a list of functions that compute hash values for the items being stored.

The time complexity for both the 'put' and 'get' operations is O(k) where k is the number of hash functions used. Since we assume k is a constant, we can say both operations are O(1). The space complexity is O(n), where n is the size of the bit array. This implementation efficiently manages space while ensuring quick membership checks.

Some edge cases to consider include: 
1. **Empty Input**: If no items have been added to the Bloom Filter, any 'get' operation should return false. 
2. **High Collision Rate**: If the hash functions are poorly chosen, they might map different inputs to the same indices, leading to increased false positives. 
3. **Large Sets**: If the number of items exceeds the expected capacity, the false positive rate will increase significantly. We should consider resizing the bit array and rehashing existing elements if a certain threshold is reached. 
4. **Invalid Inputs**: Ensure that invalid inputs (e.g., None or non-hashable types) are handled gracefully.

Implement Hash Map with without recursion

Optiver

What the Interviewer Expects

Key Topics to Cover

How to Approach This

Possible Follow-up Questions

Sharpen Your Skills on Codemia

Sample Answer

Problem Analysis

Approach

Submit Your Answer

Optiver Software Engineer Interview Guide

Related Questions

Binary Search on graph

Count kth largest element in array

Find connected components in string

Merge Three Sorted strings

Binary Search on string