Cache With Time Limit - Practice Coding Problems

Cache With Time Limit - Problem

JavaScript Medium

Design and implement a time-based cache that automatically expires keys after a specified duration. This cache supports the typical get and set operations but with a twist - each key has an associated time-to-live (TTL).

Your TimeLimitedCache class should implement these three methods:

set(key, value, duration): Stores an integer key with an integer value that expires after duration milliseconds. Returns true if an unexpired key already exists (and overwrites it), false otherwise.
get(key): Returns the value associated with the key if it exists and hasn't expired, otherwise returns -1.
count(): Returns the number of unexpired keys currently in the cache.

This type of cache is commonly used in web applications for session management, API rate limiting, and temporary data storage where automatic cleanup is essential for performance.

Input & Output

example_1.js — Basic Operations

$ Input: const cache = new TimeLimitedCache(); cache.set(1, 42, 1000); // key=1, value=42, duration=1000ms cache.get(1); // immediately after cache.count(); // count unexpired keys

› Output: false (no existing key) 42 (value retrieved) 1 (one unexpired key)

💡 Note: First set() returns false since key 1 didn't exist. get() returns 42 since the key hasn't expired yet. count() returns 1 since there's one active key.

example_2.js — Expiration Handling

$ Input: const cache = new TimeLimitedCache(); cache.set(1, 42, 100); // expires in 100ms setTimeout(() => { cache.get(1); // after expiration cache.count(); }, 200);

› Output: -1 (key expired) 0 (no unexpired keys)

💡 Note: After 200ms, the key has expired (duration was 100ms), so get() returns -1 and count() returns 0.

example_3.js — Overwriting Keys

$ Input: const cache = new TimeLimitedCache(); cache.set(1, 42, 1000); cache.set(1, 100, 1000); // overwrite same key cache.get(1); cache.count();

› Output: true (key 1 existed and was unexpired) 100 (new value) 1 (still one key)

💡 Note: Second set() returns true because key 1 existed and hadn't expired. The value is updated to 100, and count remains 1.

Constraints

1 ≤ key ≤ 10⁵
1 ≤ value ≤ 10⁹
1 ≤ duration ≤ 10⁶ milliseconds
At most 2000 calls will be made to set, get, and count
All test cases are generated such that count will return the expected value

Visualization

Tap to expand

Understanding the Visualization

Set Operation

Store key-value pair with expiration timestamp in hash map

Get Operation

Check if key exists and hasn't expired, return value or -1

Lazy Cleanup

Remove expired keys during access to free up memory

Count Operation

Count active keys and cleanup expired ones in the process

Key Takeaway

🎯 Key Insight: Lazy expiration checking combined with hash map efficiency provides O(1) operations while automatically managing memory through cleanup-on-access strategy.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28 Apple 25

The optimal solution uses a hash map with lazy expiration strategy. Instead of actively cleaning expired keys, it checks expiration only when accessing keys, achieving O(1) average time for get/set operations while automatically cleaning up expired entries during access to prevent memory bloat.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Hash Map (Optimal)	O(1) avg	O(k)	Lazy expiration checking with automatic cleanup during access
Brute Force (Check All Keys)	O(n)	O(n)	Check expiration of all keys for every operation

Optimized Hash Map (Optimal) — Algorithm Steps

Store key-value pairs with expiration timestamps in a hash map
Check expiration only when accessing keys (lazy evaluation)
Remove expired keys during access to prevent memory bloat
Use current timestamp comparison for expiration logic

Visualization

Tap to expand

Step-by-Step Walkthrough

Access Key

When accessing a key, check if it's expired

Lazy Cleanup

Remove expired keys only when accessed

Return Result

Return value or -1 based on expiration status

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <stdbool.h>
#include <string.h>

#define MAX_CACHE_SIZE 1000

typedef struct {
    int key;
    int value;
    long long expiry;
    bool active;
} CacheEntry;

typedef struct {
    CacheEntry entries[MAX_CACHE_SIZE];
    int size;
} TimeLimitedCache;

long long getCurrentTime() {
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return tv.tv_sec * 1000LL + tv.tv_usec / 1000;
}

TimeLimitedCache* createCache() {
    TimeLimitedCache* cache = malloc(sizeof(TimeLimitedCache));
    cache->size = 0;
    for (int i = 0; i < MAX_CACHE_SIZE; i++) {
        cache->entries[i].active = false;
    }
    return cache;
}

int findKey(TimeLimitedCache* cache, int key) {
    for (int i = 0; i < cache->size; i++) {
        if (cache->entries[i].active && cache->entries[i].key == key) {
            return i;
        }
    }
    return -1;
}

bool isExpired(TimeLimitedCache* cache, int index) {
    return cache->entries[index].expiry <= getCurrentTime();
}

bool set(TimeLimitedCache* cache, int key, int value, int duration) {
    long long currentTime = getCurrentTime();
    int index = findKey(cache, key);
    bool hadUnexpiredKey = false;
    
    if (index != -1) {
        hadUnexpiredKey = !isExpired(cache, index);
        cache->entries[index].value = value;
        cache->entries[index].expiry = currentTime + duration;
    } else if (cache->size < MAX_CACHE_SIZE) {
        cache->entries[cache->size].key = key;
        cache->entries[cache->size].value = value;
        cache->entries[cache->size].expiry = currentTime + duration;
        cache->entries[cache->size].active = true;
        cache->size++;
    }
    
    return hadUnexpiredKey;
}

int get(TimeLimitedCache* cache, int key) {
    int index = findKey(cache, key);
    
    if (index == -1) {
        return -1;
    }
    
    if (isExpired(cache, index)) {
        cache->entries[index].active = false; // Mark as inactive
        return -1;
    }
    
    return cache->entries[index].value;
}

int count(TimeLimitedCache* cache) {
    long long currentTime = getCurrentTime();
    int count = 0;
    
    for (int i = 0; i < cache->size; i++) {
        if (cache->entries[i].active) {
            if (cache->entries[i].expiry > currentTime) {
                count++;
            } else {
                cache->entries[i].active = false; // Cleanup expired key
            }
        }
    }
    
    return count;
}

void freeCache(TimeLimitedCache* cache) {
    free(cache);
}

Time & Space Complexity

Time Complexity

⏱️

O(1) avg

get() and set() are O(1) average, count() is O(n) but only checks active keys

✓ Linear Growth

Space Complexity

O(k)

k is the number of active (unexpired) keys, expired keys are cleaned up

✓ Linear Space

47.2K Views

High Frequency

~18 min Avg. Time

1.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

Optimized Hash Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler