Time Based Key-Value Store

Time Based Key-Value Store - Problem

Design a time-based key-value data structure that can store multiple values for the same key at different time stamps and retrieve the key's value at a certain timestamp.

Implement the TimeMap class:

TimeMap() Initializes the object of the data structure.
void set(String key, String value, int timestamp) Stores the key key with the value value at the given time timestamp.
String get(String key, int timestamp) Returns a value such that set was called previously, with timestamp_prev <= timestamp. If there are multiple such values, it returns the value associated with the largest timestamp_prev. If there are no values, it returns "".

Input & Output

Example 1 — Basic Operations

$ Input: operations = ["TimeMap", "set", "get", "get", "set", "get", "get"], parameters = [[], ["foo", "bar", 1], ["foo", 1], ["foo", 3], ["foo", "bar2", 4], ["foo", 4], ["foo", 5]]

› Output: [null, null, "bar", "bar", null, "bar2", "bar2"]

💡 Note: TimeMap created → set foo=bar at t=1 → get foo at t=1 returns "bar" → get foo at t=3 returns "bar" (t=1 ≤ 3) → set foo=bar2 at t=4 → get foo at t=4 returns "bar2" → get foo at t=5 returns "bar2" (t=4 ≤ 5)

Example 2 — No Valid Timestamp

$ Input: operations = ["TimeMap", "set", "get"], parameters = [[], ["love", "high", 10], ["love", 5]]

› Output: [null, null, ""]

💡 Note: TimeMap created → set love=high at t=10 → get love at t=5 returns "" because no timestamp ≤ 5 exists

Example 3 — Multiple Values Same Key

$ Input: operations = ["TimeMap", "set", "set", "get"], parameters = [[], ["key", "val1", 1], ["key", "val2", 3], ["key", 2]]

› Output: [null, null, null, "val1"]

💡 Note: TimeMap created → set key=val1 at t=1 → set key=val2 at t=3 → get key at t=2 returns "val1" (largest timestamp ≤ 2 is 1)

Constraints

1 ≤ key.length, value.length ≤ 100
key and value consist of lowercase English letters and digits.
1 ≤ timestamp ≤ 10⁷
All the timestamps of set are strictly increasing.
At most 2 × 10⁵ calls will be made to set and get.

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8 M Microsoft 6

The key insight is combining hash tables for O(1) key access with binary search for O(log n) timestamp lookup. The optimal approach uses a HashMap where each key maps to a sorted list of (timestamp, value) pairs, enabling efficient queries through binary search.

Common Approaches

✓ Binary Search - Optimal Solution

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

Store entries sorted by timestamp for each key. Use binary search to quickly find the largest timestamp ≤ target, achieving O(log n) query time.

Brute Force - Linear Search

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

For each key, maintain a list of (timestamp, value) pairs. When getting a value, iterate through all entries to find the largest timestamp <= target.

Binary Search - Optimal Solution — Algorithm Steps

Store (timestamp, value) pairs sorted by timestamp per key
For get(), use binary search to find rightmost valid timestamp
Return the corresponding value in O(log n) time

Visualization

Tap to expand

Step-by-Step Walkthrough

Sorted Storage

Store entries sorted by timestamp for each key

Binary Search

Use binary search to find rightmost timestamp ≤ target

Fast Result

Return corresponding value in O(log n) time

Code -

solution.c — C

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

#define MAX_ENTRIES 1000
#define MAX_KEYS 100
#define MAX_KEY_LEN 100
#define MAX_VALUE_LEN 100
#define MAX_LINE_LEN 10000
#define MAX_OPS 100

typedef struct {
    int timestamp;
    char value[MAX_VALUE_LEN];
} Entry;

typedef struct {
    char key[MAX_KEY_LEN];
    Entry entries[MAX_ENTRIES];
    int count;
} KeyData;

typedef struct {
    KeyData keys[MAX_KEYS];
    int keyCount;
} TimeMap;

TimeMap* timeMapCreate() {
    TimeMap* obj = (TimeMap*)malloc(sizeof(TimeMap));
    obj->keyCount = 0;
    return obj;
}

void timeMapSet(TimeMap* obj, char* key, char* value, int timestamp) {
    int keyIndex = -1;
    for (int i = 0; i < obj->keyCount; i++) {
        if (strcmp(obj->keys[i].key, key) == 0) {
            keyIndex = i;
            break;
        }
    }
    
    if (keyIndex == -1) {
        keyIndex = obj->keyCount;
        strcpy(obj->keys[keyIndex].key, key);
        obj->keys[keyIndex].count = 0;
        obj->keyCount++;
    }
    
    Entry* entry = &obj->keys[keyIndex].entries[obj->keys[keyIndex].count];
    entry->timestamp = timestamp;
    strcpy(entry->value, value);
    obj->keys[keyIndex].count++;
}

char* timeMapGet(TimeMap* obj, char* key, int timestamp) {
    static char result[MAX_VALUE_LEN];
    result[0] = '\0';
    
    int keyIndex = -1;
    for (int i = 0; i < obj->keyCount; i++) {
        if (strcmp(obj->keys[i].key, key) == 0) {
            keyIndex = i;
            break;
        }
    }
    
    if (keyIndex == -1) {
        return result;
    }
    
    Entry* entries = obj->keys[keyIndex].entries;
    int left = 0, right = obj->keys[keyIndex].count - 1;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (entries[mid].timestamp <= timestamp) {
            strcpy(result, entries[mid].value);
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int parseStringArray(const char* line, char operations[][20]) {
    int count = 0;
    const char* p = line;
    char temp[100];
    int inQuote = 0;
    int tempIdx = 0;
    
    while (*p) {
        if (*p == '"') {
            inQuote = !inQuote;
            if (!inQuote && tempIdx > 0) {
                temp[tempIdx] = '\0';
                strcpy(operations[count], temp);
                count++;
                tempIdx = 0;
            }
        } else if (inQuote) {
            temp[tempIdx++] = *p;
        }
        p++;
    }
    
    return count;
}

typedef struct {
    char values[10][MAX_VALUE_LEN];
    int count;
} ParamArray;

int parseParameters(const char* line, ParamArray* parameters) {
    int arrayCount = 0;
    const char* p = line;
    int inBracket = 0;
    int inQuote = 0;
    char temp[MAX_VALUE_LEN];
    int tempIdx = 0;
    
    while (*p) {
        if (*p == '[' && !inQuote) {
            if (inBracket) {
                parameters[arrayCount].count = 0;
            }
            inBracket = 1;
        } else if (*p == ']' && !inQuote) {
            if (tempIdx > 0) {
                temp[tempIdx] = '\0';
                // Remove quotes and whitespace
                char cleaned[MAX_VALUE_LEN];
                int cleanIdx = 0;
                int start = 0, end = tempIdx - 1;
                while (start < tempIdx && (temp[start] == ' ' || temp[start] == '\t')) start++;
                while (end >= 0 && (temp[end] == ' ' || temp[end] == '\t')) end--;
                
                if (end >= start && temp[start] == '"' && temp[end] == '"') {
                    start++; end--;
                }
                
                for (int i = start; i <= end; i++) {
                    cleaned[cleanIdx++] = temp[i];
                }
                cleaned[cleanIdx] = '\0';
                
                strcpy(parameters[arrayCount].values[parameters[arrayCount].count], cleaned);
                parameters[arrayCount].count++;
                tempIdx = 0;
            }
            arrayCount++;
            inBracket = 0;
        } else if (*p == '"' && inBracket) {
            inQuote = !inQuote;
            temp[tempIdx++] = *p;
        } else if (*p == ',' && !inQuote && inBracket) {
            if (tempIdx > 0) {
                temp[tempIdx] = '\0';
                // Remove quotes and whitespace
                char cleaned[MAX_VALUE_LEN];
                int cleanIdx = 0;
                int start = 0, end = tempIdx - 1;
                while (start < tempIdx && (temp[start] == ' ' || temp[start] == '\t')) start++;
                while (end >= 0 && (temp[end] == ' ' || temp[end] == '\t')) end--;
                
                if (end >= start && temp[start] == '"' && temp[end] == '"') {
                    start++; end--;
                }
                
                for (int i = start; i <= end; i++) {
                    cleaned[cleanIdx++] = temp[i];
                }
                cleaned[cleanIdx] = '\0';
                
                strcpy(parameters[arrayCount].values[parameters[arrayCount].count], cleaned);
                parameters[arrayCount].count++;
                tempIdx = 0;
            }
        } else if (inBracket) {
            temp[tempIdx++] = *p;
        }
        p++;
    }
    
    return arrayCount;
}

void formatResult(char results[][MAX_VALUE_LEN], int count, char* output) {
    strcpy(output, "[");
    for (int i = 0; i < count; i++) {
        if (i > 0) strcat(output, ",");
        if (strcmp(results[i], "null") == 0) {
            strcat(output, "null");
        } else {
            strcat(output, "\"");
            strcat(output, results[i]);
            strcat(output, "\"");
        }
    }
    strcat(output, "]");
}

int main() {
    char line[MAX_LINE_LEN];
    char operations[MAX_OPS][20];
    ParamArray parameters[MAX_OPS];
    char results[MAX_OPS][MAX_VALUE_LEN];
    
    fgets(line, sizeof(line), stdin);
    int opCount = parseStringArray(line, operations);
    
    fgets(line, sizeof(line), stdin);
    int paramCount = parseParameters(line, parameters);
    
    TimeMap* timeMap = NULL;
    int resultCount = 0;
    
    for (int i = 0; i < opCount; i++) {
        if (strcmp(operations[i], "TimeMap") == 0) {
            timeMap = timeMapCreate();
            strcpy(results[resultCount++], "null");
        } else if (strcmp(operations[i], "set") == 0) {
            char* key = parameters[i].values[0];
            char* value = parameters[i].values[1];
            int timestamp = atoi(parameters[i].values[2]);
            
            timeMapSet(timeMap, key, value, timestamp);
            strcpy(results[resultCount++], "null");
        } else if (strcmp(operations[i], "get") == 0) {
            char* key = parameters[i].values[0];
            int timestamp = atoi(parameters[i].values[1]);
            
            char* res = timeMapGet(timeMap, key, timestamp);
            strcpy(results[resultCount++], res);
        }
    }
    
    char output[MAX_LINE_LEN];
    formatResult(results, resultCount, output);
    printf("%s\n", output);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Binary search through sorted timestamps for each get() operation

✓ Linear Growth

Space Complexity

O(n)

HashMap stores all key-value-timestamp entries

⚡ Linearithmic Space

185.0K Views

High Frequency

~25 min Avg. Time

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Search - Optimal Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler