Bloom Filter - Problem

A Bloom filter is a space-efficient probabilistic data structure designed to test whether an element is a member of a set. It can return false positives but never false negatives - if it says an element is not in the set, it's definitely not there.

Implement a Bloom filter with the following operations:

BloomFilter(m, k) - Initialize with m bits and k hash functions
add(item) - Add an item to the filter
contains(item) - Check if item might be in the set (may return false positives)

For this implementation, use simple hash functions: hash_i(x) = (hash(x) + i * hash2(x)) % m where hash(x) = sum of ASCII values and hash2(x) = product of ASCII values % 997.

Input & Output

Example 1 — Basic Bloom Filter Operations

$ Input: operations = [["BloomFilter",10,3],["add","apple"],["contains","apple"],["contains","banana"]]

› Output: [null,null,true,false]

💡 Note: Create filter with 10 bits and 3 hash functions, add 'apple', check 'apple' (true), check 'banana' (false since not added)

Example 2 — Multiple Items

$ Input: operations = [["BloomFilter",8,2],["add","cat"],["add","dog"],["contains","cat"],["contains","bird"]]

› Output: [null,null,null,true,false]

💡 Note: Add 'cat' and 'dog', then check 'cat' (true) and 'bird' (false - not added)

Example 3 — Potential False Positive

$ Input: operations = [["BloomFilter",5,2],["add","a"],["contains","b"]]

› Output: [null,null,false]

💡 Note: Small filter size increases collision chance, but 'b' hashes to different positions than 'a'

Constraints

1 ≤ m ≤ 10⁴
1 ≤ k ≤ 10
1 ≤ operations.length ≤ 1000
All strings contain only lowercase English letters
1 ≤ string.length ≤ 20

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 22 M Microsoft 18

The key insight is using a bit array with multiple hash functions to achieve space-efficient probabilistic membership testing. The optimal approach uses O(m) space for the bit array and O(k) time per operation, where false positives are possible but false negatives are impossible. Time: O(k), Space: O(m).

Common Approaches

✓ Brute Force Set Storage

⏱️ Time: O(1) Space: O(n)

Use a standard set data structure to store every added item. For contains() operations, directly check if the item exists in the set. This approach is simple but uses much more memory than a Bloom filter.

True Bloom Filter Implementation

⏱️ Time: O(k) Space: O(m)

Implement a proper Bloom filter using a bit array and multiple hash functions. Items are hashed to multiple positions, and bits are set at those positions. Membership testing checks if all corresponding bits are set, allowing false positives but no false negatives.

Brute Force Set Storage — Algorithm Steps

Step 1: Initialize empty set to store all items
Step 2: For add operations, insert item into set
Step 3: For contains operations, return whether item exists in set

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create empty set

Add Items

Store each item directly

Check

Direct membership test

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#define MAX_ITEMS 1000
#define MAX_STR_LEN 100

typedef struct {
    char items[MAX_ITEMS][MAX_STR_LEN];
    int count;
} BloomFilter;

BloomFilter* createBloomFilter(int m, int k) {
    BloomFilter* bf = malloc(sizeof(BloomFilter));
    bf->count = 0;
    return bf;
}

void add(BloomFilter* bf, const char* item) {
    strcpy(bf->items[bf->count], item);
    bf->count++;
}

bool contains(BloomFilter* bf, const char* item) {
    for (int i = 0; i < bf->count; i++) {
        if (strcmp(bf->items[i], item) == 0) {
            return true;
        }
    }
    return false;
}

int main() {
    // Implementation for C would require manual JSON parsing
    // This is a simplified version
    BloomFilter* bloom = NULL;
    
    // Parse operations and execute
    // Print results in JSON format
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Set operations (add/contains) are O(1) on average

✓ Linear Growth

Space Complexity

O(n)

Must store every added item in memory

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Bloom Filter - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Set Storage — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler