Design Log Storage System

Design Log Storage System - Problem

You are given several logs, where each log contains a unique ID and timestamp. Timestamp is a string that has the following format: Year:Month:Day:Hour:Minute:Second, for example, 2017:01:01:23:59:59. All domains are zero-padded decimal numbers.

Implement the LogSystem class:

LogSystem() Initializes the LogSystem object.
void put(int id, string timestamp) Stores the given log (id, timestamp) in your storage system.
int[] retrieve(string start, string end, string granularity) Returns the IDs of the logs whose timestamps are within the range from start to end inclusive. start and end all have the same format as timestamp, and granularity means how precise the range should be (i.e. to the exact Day, Minute, etc.).

For example, start = "2017:01:01:23:59:59", end = "2017:01:02:23:59:59", and granularity = "Day" means that we need to find the logs within the inclusive range from Jan. 1st 2017 to Jan. 2nd 2017, and the Hour, Minute, and Second for each log entry can be ignored.

Input & Output

Example 1 — Basic Log System Operations

$ Input: [["LogSystem"], ["put", 1, "2017:01:01:23:59:59"], ["put", 2, "2017:01:01:22:59:59"], ["put", 3, "2016:01:01:00:00:00"], ["retrieve", "2016:01:01:01:01:01", "2017:01:01:23:00:00", "Year"], ["retrieve", "2016:01:01:01:01:01", "2017:01:01:23:00:00", "Hour"]]

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

💡 Note: LogSystem created, logs stored, then retrieved by Year granularity (ignores month/day/hour details) and Hour granularity (more precise filtering)

Example 2 — Day Granularity Filter

$ Input: [["LogSystem"], ["put", 1, "2017:01:01:23:59:59"], ["put", 2, "2017:01:02:23:59:59"], ["put", 3, "2017:01:03:23:59:59"], ["retrieve", "2017:01:01:00:00:00", "2017:01:02:23:59:59", "Day"]]

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

💡 Note: Day granularity means compare only YYYY:MM:DD parts, so logs from Jan 1st and Jan 2nd match the range, Jan 3rd is excluded

Example 3 — Month Granularity

$ Input: [["LogSystem"], ["put", 1, "2017:01:15:10:30:45"], ["put", 2, "2017:02:20:12:45:30"], ["retrieve", "2017:01:01:00:00:00", "2017:01:31:23:59:59", "Month"]]

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

💡 Note: Month granularity compares YYYY:MM only, so only log from January 2017 matches

Constraints

1 ≤ id ≤ 10⁶
2000 ≤ Year ≤ 2017
1 ≤ Month ≤ 12
1 ≤ Day ≤ 31
0 ≤ Hour ≤ 23
0 ≤ Minute, Second ≤ 59
granularity is one of ["Year", "Month", "Day", "Hour", "Minute", "Second"]

Visualization

Tap to expand

Asked in

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

The key insight is to truncate timestamps based on granularity before comparison. Map each granularity level to a substring length, then compare only the relevant prefix portions of timestamps. Best approach uses simple storage with granularity mapping. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force Linear Search

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

Keep logs in a simple list and for each retrieve operation, iterate through all logs to check if their timestamps fall within the specified range after adjusting for granularity.

Optimized with Sorted Storage

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

Keep logs sorted by timestamp and use the granularity mapping to efficiently compare timestamp ranges. This allows for better performance in retrieve operations.

Brute Force Linear Search — Algorithm Steps

Store each log entry in a list
For retrieve: iterate through all logs
Truncate timestamps based on granularity
Compare truncated timestamps with range

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Logs

Add logs to simple list

Truncate Timestamps

Cut timestamps based on granularity

Linear Search

Check each log against range

Code -

solution.c — C

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

#define MAX_LOGS 1000
#define MAX_TIMESTAMP 20

typedef struct {
    int id;
    char timestamp[MAX_TIMESTAMP];
} Log;

typedef struct {
    Log logs[MAX_LOGS];
    int count;
} LogSystem;

LogSystem* logSystemCreate() {
    LogSystem* obj = (LogSystem*)malloc(sizeof(LogSystem));
    obj->count = 0;
    return obj;
}

void logSystemPut(LogSystem* obj, int id, char* timestamp) {
    obj->logs[obj->count].id = id;
    strcpy(obj->logs[obj->count].timestamp, timestamp);
    obj->count++;
}

int getGranularityLength(char* granularity) {
    if (strcmp(granularity, "Year") == 0) return 4;
    if (strcmp(granularity, "Month") == 0) return 7;
    if (strcmp(granularity, "Day") == 0) return 10;
    if (strcmp(granularity, "Hour") == 0) return 13;
    if (strcmp(granularity, "Minute") == 0) return 16;
    if (strcmp(granularity, "Second") == 0) return 19;
    return 19;
}

int* logSystemRetrieve(LogSystem* obj, char* start, char* end, char* granularity, int* returnSize) {
    int length = getGranularityLength(granularity);
    int* result = (int*)malloc(MAX_LOGS * sizeof(int));
    *returnSize = 0;
    
    char startTruncated[MAX_TIMESTAMP], endTruncated[MAX_TIMESTAMP];
    strncpy(startTruncated, start, length);
    startTruncated[length] = '\0';
    strncpy(endTruncated, end, length);
    endTruncated[length] = '\0';
    
    for (int i = 0; i < obj->count; i++) {
        char timestampTruncated[MAX_TIMESTAMP];
        strncpy(timestampTruncated, obj->logs[i].timestamp, length);
        timestampTruncated[length] = '\0';
        
        if (strcmp(startTruncated, timestampTruncated) <= 0 && 
            strcmp(timestampTruncated, endTruncated) <= 0) {
            result[*returnSize] = obj->logs[i].id;
            (*returnSize)++;
        }
    }
    
    return result;
}

int main() {
    printf("[[]]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each retrieve operation scans all n stored logs

✓ Linear Growth

Space Complexity

O(n)

Store all n logs in memory

⚡ Linearithmic Space

28.5K Views

Medium 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Linear Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler