Observable Data Store - Problem

Design and implement an Observable Data Store that allows multiple listeners to be notified whenever data changes. The store should support setting values, getting values, and registering/unregistering listeners.

Your implementation should include:

DataStore class with methods to set/get data
addListener(key, callback) - register a callback for a specific key
removeListener(key, callback) - unregister a callback
set(key, value) - update value and notify all listeners for that key
get(key) - retrieve current value

When a value changes, all registered listeners for that key should be called with the new value.

Input & Output

Example 1 — Basic Operations

$ Input: operations = [["addListener","temp",1],["addListener","temp",2],["set","temp",25],["get","temp"]]

› Output: [null,null,[1,2],25]

💡 Note: Add two listeners for 'temp', then set temp=25 which notifies both listeners [1,2], finally get returns 25

Example 2 — Multiple Keys

$ Input: operations = [["addListener","temp",1],["addListener","light",2],["set","temp",20],["set","light",true]]

› Output: [null,null,[1],[2]]

💡 Note: Separate listeners for different keys: temp change notifies [1], light change notifies [2]

Example 3 — Remove Listener

$ Input: operations = [["addListener","temp",1],["addListener","temp",2],["removeListener","temp",1],["set","temp",30]]

› Output: [null,null,null,[2]]

💡 Note: After removing listener 1, only listener 2 gets notified when temp changes to 30

Constraints

1 ≤ operations.length ≤ 1000
Each operation is valid according to the method signatures
Keys are non-empty strings
Values can be any type (int, string, boolean, etc.)

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 N Netflix 8 U Uber 6

The Observable Data Store implements the Observer Pattern using a hash map to group listeners by key. The key insight is using listeners[key] → [callback1, callback2, ...] for O(k) notification time where k is the number of listeners for that specific key. Best approach: Hash Map Grouping. Time: O(k) per notification, Space: O(n) for all listeners.

Common Approaches

✓ Brute Force - Check All Listeners

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

Maintain a single list of all listeners with their keys and callbacks. When data changes, iterate through the entire list to find matching listeners.

Optimized - Hash Map by Key

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

Use a hash map where each key maps to an array of its listeners. When data changes, directly access only the relevant listeners.

Brute Force - Check All Listeners — Algorithm Steps

Store all listeners in one global array
On data change, loop through every listener
Check if listener's key matches changed key
Call matching callbacks with new value

Visualization

Tap to expand

Step-by-Step Walkthrough

Store All Listeners

Keep all listeners in a single array regardless of key

Data Changes

When set('temp', 25) is called, scan entire listener array

Linear Search

Check each listener: does key match 'temp'? If yes, notify

Result

Found matching listeners get called with new value

Code -

solution.c — C

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

#define MAX_LISTENERS 100
#define MAX_KEY_LEN 50

typedef struct {
    char key[MAX_KEY_LEN];
    int callbackId;
} Listener;

typedef struct {
    char keys[MAX_LISTENERS][MAX_KEY_LEN];
    int values[MAX_LISTENERS];
    int dataCount;
    Listener listeners[MAX_LISTENERS];
    int listenerCount;
} DataStore;

DataStore* createDataStore() {
    DataStore* store = (DataStore*)malloc(sizeof(DataStore));
    store->dataCount = 0;
    store->listenerCount = 0;
    return store;
}

void addListener(DataStore* store, const char* key, int callbackId) {
    strcpy(store->listeners[store->listenerCount].key, key);
    store->listeners[store->listenerCount].callbackId = callbackId;
    store->listenerCount++;
}

void removeListener(DataStore* store, const char* key, int callbackId) {
    int writeIndex = 0;
    for (int i = 0; i < store->listenerCount; i++) {
        if (!(strcmp(store->listeners[i].key, key) == 0 && store->listeners[i].callbackId == callbackId)) {
            store->listeners[writeIndex++] = store->listeners[i];
        }
    }
    store->listenerCount = writeIndex;
}

int* setValue(DataStore* store, const char* key, int value, int* notificationCount) {
    // Find or create data entry
    int dataIndex = -1;
    for (int i = 0; i < store->dataCount; i++) {
        if (strcmp(store->keys[i], key) == 0) {
            dataIndex = i;
            break;
        }
    }
    
    if (dataIndex == -1) {
        strcpy(store->keys[store->dataCount], key);
        dataIndex = store->dataCount++;
    }
    
    store->values[dataIndex] = value;
    
    // Find notifications
    static int notifications[MAX_LISTENERS];
    *notificationCount = 0;
    for (int i = 0; i < store->listenerCount; i++) {
        if (strcmp(store->listeners[i].key, key) == 0) {
            notifications[(*notificationCount)++] = store->listeners[i].callbackId;
        }
    }
    
    return notifications;
}

int getValue(DataStore* store, const char* key) {
    for (int i = 0; i < store->dataCount; i++) {
        if (strcmp(store->keys[i], key) == 0) {
            return store->values[i];
        }
    }
    return -1;
}

int main() {
    // Simplified implementation
    printf("[]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Must check every listener to find matches for each data change

✓ Linear Growth

Space Complexity

O(n)

Store all listeners in a single array

⚡ Linearithmic Space

28.0K 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

Observable Data Store - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Listeners — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler