Cache With Time Limit

Cache With Time Limit - Problem

JavaScript Medium

Design a time-based cache class that allows getting and setting key-value pairs with expiration times.

The class should have three public methods:

set(key, value, duration): Accepts an integer key, integer value, and duration in milliseconds. Returns true if the same unexpired key already exists, false otherwise. Overwrites both value and duration if key exists.
get(key): Returns the associated value if an unexpired key exists, otherwise returns -1.
count(): Returns the count of unexpired keys.

Keys automatically become inaccessible once their duration has elapsed.

Input & Output

Example 1 — Basic Cache Operations

$ Input: operations = [["set", 1, 42, 1000], ["get", 1], ["count"], ["get", 1]]

› Output: [false, 42, 1, 42]

💡 Note: Set key 1 to 42 with 1000ms TTL (returns false - no existing key). Get key 1 returns 42. Count returns 1 active key. Get key 1 again still returns 42.

Example 2 — Key Overwrite

$ Input: operations = [["set", 1, 10, 1000], ["set", 1, 20, 2000], ["get", 1]]

› Output: [false, true, 20]

💡 Note: First set returns false (no existing key). Second set returns true (key 1 exists and is valid). Get returns new value 20.

Example 3 — Expiration Test

$ Input: operations = [["set", 1, 100, 50], ["count"], ["count"]]

› Output: [false, 1, 0]

💡 Note: Set key 1 with 50ms TTL. First count returns 1. After 50ms delay, second count returns 0 (expired).

Constraints

1 ≤ operations.length ≤ 100
0 ≤ key ≤ 10⁵
1 ≤ value ≤ 10⁸
1 ≤ duration ≤ 1000

Visualization

Tap to expand

Asked in

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

The key insight is to store each cache entry with its expiration timestamp and validate on access. Use a Map to store key-value pairs along with expiration times, checking current time vs expiration on every operation. Best approach uses lazy cleanup with periodic maintenance for memory efficiency. Time: O(1), Space: O(n)

Common Approaches

✓ Two Pointers

⏱️ Time: N/A Space: N/A

Lazy Cleanup with Background Timer

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

Use the same timestamp-based validation but add periodic cleanup to remove expired entries proactively, reducing memory usage over time.

Store with Expiration Check

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

Store each key-value pair along with its expiration time. For every get/count operation, check if the current time exceeds the expiration time.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int isMatch(char* query, char* pattern) {
    int i = 0, j = 0;
    int qlen = strlen(query), plen = strlen(pattern);
    
    while (i < qlen) {
        if (j < plen && query[i] == pattern[j]) {
            i++;
            j++;
        } else if (islower(query[i])) {
            i++;
        } else {
            return 0;
        }
    }
    
    return j == plen;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    char* queries[1000];
    int count = 0;
    
    if (strcmp(line, "[]") != 0) {
        char* token = strtok(line + 1, ",");
        while (token) {
            while (*token == ' ' || *token == '"') token++;
            char* end = token + strlen(token) - 1;
            while (end > token && (*end == ' ' || *end == '"' || *end == ']')) *end-- = 0;
            
            queries[count] = malloc(strlen(token) + 1);
            strcpy(queries[count], token);
            count++;
            
            token = strtok(NULL, ",");
        }
    }
    
    char pattern[1000];
    fgets(pattern, sizeof(pattern), stdin);
    pattern[strcspn(pattern, "\n")] = 0;
    
    printf("[");
    for (int i = 0; i < count; i++) {
        if (i > 0) printf(",");
        printf(isMatch(queries[i], pattern) ? "true" : "false");
    }
    printf("]\n");
    
    for (int i = 0; i < count; i++) {
        free(queries[i]);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

892 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