Cache with Expiry - Problem

Design and implement a Cache with Expiry that stores key-value pairs with a time-to-live (TTL) mechanism.

Your cache should support the following operations:

put(key, value, ttl) - Store a key-value pair that expires after ttl seconds
get(key) - Retrieve the value for a key if it hasn't expired, otherwise return null
delete(key) - Remove a key from the cache
size() - Return the number of non-expired keys currently in the cache

Keys expire based on the TTL (time-to-live) value provided when they were stored. Once a key expires, it should be treated as if it doesn't exist in the cache.

Input & Output

Example 1 — Basic Cache Operations

$ Input: operations = [["put","key1","value1",5], ["get","key1"], ["size"], ["get","key1"], ["size"]]

› Output: [null, "value1", 1, null, 0]

💡 Note: Put key1 with 5-second TTL, get immediately returns value1, size is 1. After 5+ seconds, key1 expires so get returns null and size becomes 0.

Example 2 — Multiple Keys with Different TTLs

$ Input: operations = [["put","a","apple",3], ["put","b","banana",10], ["get","a"], ["get","b"], ["size"]]

› Output: [null, null, "apple", "banana", 2]

💡 Note: Store 'a' for 3 seconds and 'b' for 10 seconds. Both are accessible initially, and cache size is 2.

Example 3 — Delete Operation

$ Input: operations = [["put","x","test",60], ["delete","x"], ["get","x"], ["delete","x"]]

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

💡 Note: Put 'x' with 60-second TTL. Delete returns true (key existed). Get returns null (key was deleted). Second delete returns false (key doesn't exist).

Constraints

1 ≤ operations.length ≤ 1000
operations[i] is one of ["put", "get", "delete", "size"]
1 ≤ key.length, value.length ≤ 100
1 ≤ ttl ≤ 10⁹ seconds

Visualization

Tap to expand

Asked in

a Amazon 45 G Google 38 M Microsoft 32 f Facebook 28

The key insight is using a hash map with timestamp-based expiry checking. Store each value with its expiration time and check validity only when accessing keys. The lazy expiry approach provides O(1) operations by avoiding unnecessary cleanup. Best approach: Lazy Expiry Check - Time: O(1) for get/put/delete, Space: O(n).

Common Approaches

✓ Brute Force with Full Cache Cleanup

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

For every get, put, or size operation, iterate through all cache entries to remove expired ones first, then perform the requested operation. This ensures accuracy but is very inefficient.

Lazy Expiry Check

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

Instead of cleaning the entire cache, check if a key has expired only when it's accessed (get/put/delete). This reduces unnecessary work but may leave expired entries in memory.

Brute Force with Full Cache Cleanup — Algorithm Steps

Iterate through all cache entries
Remove any expired entries
Perform the requested operation
Return the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Operation Request

User requests get('key1')

Full Cleanup Scan

Check ALL entries for expiration

Remove Expired

Delete any expired entries found

Perform Operation

Execute the original request

Code -

solution.c — C

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

#define MAX_OPERATIONS 1000
#define MAX_KEY_LEN 100
#define MAX_VALUE_LEN 100

typedef struct {
    char key[MAX_KEY_LEN];
    char value[MAX_VALUE_LEN];
    long long expiry_time;
    int active;
} CacheEntry;

typedef struct {
    CacheEntry entries[MAX_OPERATIONS];
    int count;
} CacheWithExpiry;

long long getCurrentTimeMillis() {
    return (long long)(time(NULL) * 1000);
}

void cleanupExpired(CacheWithExpiry* cache) {
    long long currentTime = getCurrentTimeMillis();
    for (int i = 0; i < cache->count; i++) {
        if (cache->entries[i].active && currentTime > cache->entries[i].expiry_time) {
            cache->entries[i].active = 0;
        }
    }
}

void put(CacheWithExpiry* cache, const char* key, const char* value, int ttl) {
    cleanupExpired(cache);
    long long expiryTime = getCurrentTimeMillis() + ttl * 1000LL;
    
    for (int i = 0; i < cache->count; i++) {
        if (strcmp(cache->entries[i].key, key) == 0) {
            strcpy(cache->entries[i].value, value);
            cache->entries[i].expiry_time = expiryTime;
            cache->entries[i].active = 1;
            return;
        }
    }
    
    strcpy(cache->entries[cache->count].key, key);
    strcpy(cache->entries[cache->count].value, value);
    cache->entries[cache->count].expiry_time = expiryTime;
    cache->entries[cache->count].active = 1;
    cache->count++;
}

char* get(CacheWithExpiry* cache, const char* key) {
    cleanupExpired(cache);
    for (int i = 0; i < cache->count; i++) {
        if (cache->entries[i].active && strcmp(cache->entries[i].key, key) == 0) {
            return cache->entries[i].value;
        }
    }
    return NULL;
}

int delete(CacheWithExpiry* cache, const char* key) {
    cleanupExpired(cache);
    for (int i = 0; i < cache->count; i++) {
        if (cache->entries[i].active && strcmp(cache->entries[i].key, key) == 0) {
            cache->entries[i].active = 0;
            return 1;
        }
    }
    return 0;
}

int size(CacheWithExpiry* cache) {
    cleanupExpired(cache);
    int count = 0;
    for (int i = 0; i < cache->count; i++) {
        if (cache->entries[i].active) {
            count++;
        }
    }
    return count;
}

int main() {
    CacheWithExpiry cache = {0};
    char operation[20], key[MAX_KEY_LEN], value[MAX_VALUE_LEN];
    int ttl;
    
    printf("[null]");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Every operation requires scanning all n entries to remove expired ones

✓ Linear Growth

Space Complexity

O(n)

Hash map stores up to n active key-value pairs with timestamps

⚡ Linearithmic Space

34.2K Views

High 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

Cache with Expiry - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with Full Cache Cleanup — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler