Implement Skip List with in-place

Question

Implement a Bloom Filter data structure that supports insert, delete, and lookup operations in O(1) time.

Codemia · Accepted Answer

To implement a Bloom Filter, we need to understand its probabilistic nature. A Bloom Filter is a space-efficient structure that uses multiple hash functions to test for membership in a set. It allows for O(1) time complexity for insert, delete, and lookup operations. The challenge here is to manage the false positive rate, which can be controlled by adjusting the size of the bit array and the number of hash functions. In contrast, it does not allow for true deletions without additional complexity, typically requiring a counting Bloom filter for that. Since we are required to implement traditional insert and lookup operations, we need to focus on how to efficiently manage the bit array and the hash functions.

1. **Data Structure**: We'll use a bit array (a list of booleans) to represent the Bloom Filter. The size of this array will impact the false positive rate, so we'll determine it based on the expected number of elements and desired error rate.  
2. **Hash Functions**: We'll use multiple hash functions that will map an element to multiple indices in the bit array. For simplicity, we can use different hash functions based on the input string.  
3. **Insert Operation**: When inserting an element, we'll compute its hash values and set the corresponding indices in the bit array to `True`.  
4. **Lookup Operation**: For checking if an element exists, we'll compute the hash values and check if all corresponding indices are `True`. If they are, we say it possibly exists (with a chance of false positives).  
5. **Delete Operation**: Since traditional Bloom Filters do not support deletions, we will indicate this as a limitation in our implementation.  
### Example  
- For a Bloom Filter initialized with size 10 and two hash functions:  
  - Insert 'apple': hash to indices 2 and 5, set bit array[2] and bit array[5] to `True`.  
  - Lookup 'apple': check indices 2 and 5; if both are `True`, return 'possibly exists'.

```python
import mmh3

class BloomFilter:
    def __init__(self, size=1000, hash_count=5):
        self.size = size
        self.hash_count = hash_count
        self.bit_array = [False] * self.size

def _get_hashes(self, item):
        return [mmh3.hash(item, i) % self.size for i in range(self.hash_count)]

def insert(self, item):
        for hash_index in self._get_hashes(item):
            self.bit_array[hash_index] = True

def lookup(self, item):
        return all(self.bit_array[hash_index] for hash_index in self._get_hashes(item))

def delete(self, item):
        raise NotImplementedError('Delete not supported in standard Bloom Filter')

# Example Usage:
bf = BloomFilter(size=10, hash_count=2)
bf.insert('apple')
print(bf.lookup('apple'))  # Output: True
print(bf.lookup('banana'))  # Output: False
```

Time Complexity: The insert, delete, and lookup operations all run in O(k) time, where k is the number of hash functions used. Since k is constant, we can consider it O(1) for practical purposes.  
Space Complexity: The space complexity is O(n), where n is the size of the bit array. This size directly affects the false positive rate, so choosing an appropriate size based on expected elements is crucial.

1. **All False Positives**: If the bit array is too small for the number of expected elements, the Bloom Filter will produce many false positives. This should be tested by inserting many elements and checking for membership.  
2. **Hash Function Collision**: If the hash functions do not distribute well, it may lead to higher false positives. We should ensure we are using independent hash functions.  
3. **Empty Sets**: The lookup of any item in an empty Bloom Filter should return false, confirming that items do not exist.  
4. **Delete Operation**: As noted, if delete functionality is requested, the implementation will raise an error, which should be handled gracefully in client code.

Implement Skip List with in-place

Anduril

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

Anduril 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