Design Authentication Manager - Practice Coding Problems

Design Authentication Manager - Problem

🔐 Authentication Token Manager

You're building a secure authentication system that manages user session tokens with automatic expiration. Think of it like a digital bouncer that checks if tokens are still valid!

Your system needs to handle four key operations:

AuthenticationManager(timeToLive) - Initialize the system with a token lifetime
generate(tokenId, currentTime) - Create a new token that expires after timeToLive seconds
renew(tokenId, currentTime) - Extend an unexpired token's lifetime
countUnexpiredTokens(currentTime) - Count how many tokens are still active

Important: If a token expires exactly at time t, it's considered expired before any other operations at time t.

Example: If timeToLive = 5 and you generate token "abc" at time 10, it expires at time 15. If you call countUnexpiredTokens(15), this token won't be counted!

Input & Output

example_1.py — Basic Operations

$ Input: ["AuthenticationManager", "renew", "generate", "countUnexpiredTokens", "generate", "renew", "renew", "countUnexpiredTokens"] [[5], ["aaa", 1], ["aaa", 2], [6], ["bbb", 7], ["aaa", 8], ["bbb", 10], [15]]

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

💡 Note: AuthenticationManager(5): timeToLive = 5. renew("aaa", 1): No token "aaa" exists, ignore. generate("aaa", 2): Token "aaa" expires at time 7. countUnexpiredTokens(6): Token "aaa" is still valid (7 > 6). generate("bbb", 7): Token "bbb" expires at time 12. renew("aaa", 8): Token "aaa" expired at time 7, ignore. renew("bbb", 10): Token "bbb" renewed, now expires at time 15. countUnexpiredTokens(15): All tokens expired.

example_2.py — Edge Case with Same Time

$ Input: ["AuthenticationManager", "generate", "countUnexpiredTokens", "countUnexpiredTokens"] [[3], ["token1", 10], [13], [14]]

› Output: [null, null, 0, 0]

💡 Note: Token generated at time 10 with timeToLive=3 expires exactly at time 13. When counting at time 13, the token is considered expired (expiration happens before counting). At time 14, it's still expired.

example_3.py — Multiple Renewals

$ Input: ["AuthenticationManager", "generate", "renew", "renew", "countUnexpiredTokens"] [[4], ["token", 5], ["token", 8], ["token", 11], [15]]

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

💡 Note: Token created at time 5 (expires at 9), renewed at time 8 (expires at 12), renewed again at time 11 (expires at 15). At time 15, it expires exactly then, but we count before expiration, so it's valid.

Constraints

1 ≤ timeToLive ≤ 10⁸
1 ≤ currentTime ≤ 10⁸
1 ≤ tokenId.length ≤ 5
tokenId consists only of lowercase letters
At most 2000 calls will be made to generate, renew, and countUnexpiredTokens

Visualization

Tap to expand

Understanding the Visualization

Token Generation

Create a new token with expiration time = currentTime + timeToLive

Token Renewal

Extend valid token's expiration time (like renewing a library book)

Expiration Check

Count only tokens where expiryTime > currentTime

Lazy Cleanup

Remove expired tokens when encountered to save memory

Key Takeaway

🎯 Key Insight: Hash tables provide O(1) average access time for tokens, while lazy deletion keeps memory usage reasonable by cleaning up expired tokens only when necessary.

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal approach uses a hash table to map tokenId to expiration time, providing O(1) average time for generate and renew operations. The key insight is using lazy deletion - only cleaning up expired tokens when we encounter them during count operations, balancing efficiency with memory usage.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Table with Lazy Deletion (Optimal)	O(1) average for generate/renew, O(n) for count	O(n)	Use hash map for O(1) operations with lazy cleanup of expired tokens
Brute Force (Check All Tokens)	O(n)	O(n)	Store all tokens and check expiration every time

Hash Table with Lazy Deletion (Optimal) — Algorithm Steps

Use a hash table to map tokenId to expiration time
For generate: simply add/update the token with new expiration time
For renew: check if token exists and is not expired, then update
For count: iterate through hash table and count unexpired tokens
Use lazy deletion - only remove expired tokens when encountered

Visualization

Tap to expand

Step-by-Step Walkthrough

Hash Table Storage

Tokens stored as key-value pairs

O(1) Operations

Generate and renew are instant lookups

Lazy Cleanup

Remove expired tokens during count operations

Code -

solution.c — C

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

#define MAX_TOKENS 1000
#define MAX_TOKEN_LEN 100

typedef struct {
    char tokenId[MAX_TOKEN_LEN + 1];
    int expiryTime;
    int isActive;
} Token;

typedef struct {
    int timeToLive;
    Token tokens[MAX_TOKENS];
    int tokenCount;
} AuthenticationManager;

int findTokenIndex(AuthenticationManager* obj, char* tokenId) {
    for (int i = 0; i < obj->tokenCount; i++) {
        if (obj->tokens[i].isActive && strcmp(obj->tokens[i].tokenId, tokenId) == 0) {
            return i;
        }
    }
    return -1;
}

AuthenticationManager* authenticationManagerCreate(int timeToLive) {
    AuthenticationManager* am = malloc(sizeof(AuthenticationManager));
    am->timeToLive = timeToLive;
    am->tokenCount = 0;
    for (int i = 0; i < MAX_TOKENS; i++) {
        am->tokens[i].isActive = 0;
    }
    return am;
}

void authenticationManagerGenerate(AuthenticationManager* obj, char* tokenId, int currentTime) {
    int index = findTokenIndex(obj, tokenId);
    if (index != -1) {
        obj->tokens[index].expiryTime = currentTime + obj->timeToLive;
    } else {
        strcpy(obj->tokens[obj->tokenCount].tokenId, tokenId);
        obj->tokens[obj->tokenCount].expiryTime = currentTime + obj->timeToLive;
        obj->tokens[obj->tokenCount].isActive = 1;
        obj->tokenCount++;
    }
}

void authenticationManagerRenew(AuthenticationManager* obj, char* tokenId, int currentTime) {
    int index = findTokenIndex(obj, tokenId);
    if (index != -1 && obj->tokens[index].expiryTime > currentTime) {
        obj->tokens[index].expiryTime = currentTime + obj->timeToLive;
    }
}

int authenticationManagerCountUnexpiredTokens(AuthenticationManager* obj, int currentTime) {
    int count = 0;
    for (int i = 0; i < obj->tokenCount; i++) {
        if (obj->tokens[i].isActive) {
            if (obj->tokens[i].expiryTime > currentTime) {
                count++;
            } else {
                obj->tokens[i].isActive = 0; // Lazy deletion
            }
        }
    }
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(1) average for generate/renew, O(n) for count

Hash table operations are O(1) average, counting requires iterating all tokens

✓ Linear Growth

Space Complexity

O(n)

Hash table stores all active tokens plus potentially some expired ones

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

834 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

🔐 Authentication Token Manager

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Hash Table with Lazy Deletion (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler