Tweet Counts Per Frequency

Tweet Counts Per Frequency - Problem

Hash Table String Binary Search Design Sorting Ordered Set Medium

A social media company is trying to monitor activity on their site by analyzing the number of tweets that occur in select periods of time. These periods can be partitioned into smaller time chunks based on a certain frequency (every minute, hour, or day).

For example, the period [10, 10000] (in seconds) would be partitioned into the following time chunks with these frequencies:

Every minute (60-second chunks): [10,69], [70,129], [130,189], ..., [9970,10000]
Every hour (3600-second chunks): [10,3609], [3610,7209], [7210,10000]
Every day (86400-second chunks): [10,10000]

Notice that the last chunk may be shorter than the specified frequency's chunk size and will always end with the end time of the period.

Design and implement an API to help the company with their analysis.

Implement the TweetCounts class:

TweetCounts() Initializes the TweetCounts object.
void recordTweet(String tweetName, int time) Stores the tweetName at the recorded time (in seconds).
List<Integer> getTweetCountsPerFrequency(String freq, String tweetName, int startTime, int endTime) Returns a list of integers representing the number of tweets with tweetName in each time chunk for the given period of time [startTime, endTime] (in seconds) and frequency freq.

freq is one of "minute", "hour", or "day" representing a frequency of every minute, hour, or day respectively.

Input & Output

Example 1 — Basic Tweet Recording and Querying

$ Input: operations = ["TweetCounts","recordTweet","recordTweet","getTweetCountsPerFrequency"], params = [[],["tweet3",0],["tweet3",60],["minute","tweet3",0,59]]

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

💡 Note: Initialize TweetCounts, record tweet3 at time 0, record tweet3 at time 60, then query minute frequency for tweet3 from 0 to 59. Only the tweet at time 0 falls in range [0,59].

Example 2 — Multiple Time Chunks

$ Input: operations = ["TweetCounts","recordTweet","recordTweet","recordTweet","getTweetCountsPerFrequency"], params = [[],["tweet3",0],["tweet3",60],["tweet3",120],["minute","tweet3",0,179]]

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

💡 Note: Record tweets at times 0, 60, 120. Query minute frequency from 0 to 179 creates chunks [0,59],[60,119],[120,179], each containing 1 tweet.

Example 3 — Hour Frequency with Multiple Tweets

$ Input: operations = ["TweetCounts","recordTweet","recordTweet","recordTweet","getTweetCountsPerFrequency"], params = [[],["tweet1",100],["tweet1",3700],["tweet1",7300],["hour","tweet1",0,7199]]

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

💡 Note: Record tweets at 100, 3700, 7300. Query hour frequency [0,7199] creates one chunk [0,3599] containing tweets at 100 and 3700 (7300 is outside range).

Constraints

0 ≤ time ≤ 10⁹
0 ≤ startTime ≤ endTime ≤ 10⁹
freq is one of "minute", "hour", or "day"
At most 10⁴ calls to recordTweet and getTweetCountsPerFrequency

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8 t Twitter 10

The key insight is to use a HashMap to group timestamps by tweet name, and maintain them in sorted order for efficient range queries. The optimized approach uses binary search to find timestamp ranges in O(log n) time per chunk. Best approach: Binary Search with Time: O(c × log n), Space: O(n).

Common Approaches

✓ Brute Force - Linear Search

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

For each tweet name, store all timestamps in a list. When querying, iterate through all timestamps and count those within each time chunk.

Optimized - Binary Search

⏱️ Time: O(c × log n) Space: O(n)

Store timestamps for each tweet name in sorted order. For each time chunk, use binary search to find the range of timestamps and count them efficiently.

Brute Force - Linear Search — Algorithm Steps

Store all tweet timestamps in lists grouped by name
For each query, scan all timestamps linearly
Count tweets falling in each time chunk

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Tweets

Add timestamps to lists by tweet name

Linear Search

For each chunk, scan all timestamps

Count Matches

Count timestamps within chunk range

Code -

solution.c — C

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

#define MAX_TWEETS 10000
#define MAX_NAME_LEN 100
#define MAX_OPERATIONS 1000
#define MAX_STRINGS 10
#define MAX_INTS 10

typedef struct {
    char names[MAX_TWEETS][MAX_NAME_LEN];
    int times[MAX_TWEETS];
    int count;
} TweetCounts;

typedef struct {
    char stringVals[MAX_STRINGS][MAX_NAME_LEN];
    int stringCount;
    int intVals[MAX_INTS];
    int intCount;
} ParamSet;

TweetCounts* tweetCountsCreate() {
    TweetCounts* obj = (TweetCounts*)malloc(sizeof(TweetCounts));
    obj->count = 0;
    return obj;
}

void tweetCountsRecordTweet(TweetCounts* obj, char* tweetName, int time) {
    strcpy(obj->names[obj->count], tweetName);
    obj->times[obj->count] = time;
    obj->count++;
}

int* tweetCountsGetTweetCountsPerFrequency(TweetCounts* obj, char* freq, char* tweetName, int startTime, int endTime, int* returnSize) {
    int interval;
    if (strcmp(freq, "minute") == 0) interval = 60;
    else if (strcmp(freq, "hour") == 0) interval = 3600;
    else interval = 86400;
    
    int* result = (int*)malloc(1000 * sizeof(int));
    *returnSize = 0;
    int current = startTime;
    
    while (current <= endTime) {
        int chunkEnd = (current + interval - 1 < endTime) ? current + interval - 1 : endTime;
        int count = 0;
        
        for (int i = 0; i < obj->count; i++) {
            if (strcmp(obj->names[i], tweetName) == 0 && obj->times[i] >= current && obj->times[i] <= chunkEnd) {
                count++;
            }
        }
        
        result[*returnSize] = count;
        (*returnSize)++;
        current += interval;
    }
    
    return result;
}

void parseStringArray(const char* str, char operations[][20], int* opCount) {
    *opCount = 0;
    const char* p = str;
    
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        if (*p == '"') {
            p++;
            int len = 0;
            while (*p && *p != '"') {
                operations[*opCount][len++] = *p++;
            }
            operations[*opCount][len] = '\0';
            (*opCount)++;
            if (*p == '"') p++;
        } else {
            p++;
        }
    }
}

void parseParams(const char* str, ParamSet* params, int* paramCount) {
    *paramCount = 0;
    const char* p = str;
    
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        if (*p == '[') {
            p++;
            params[*paramCount].stringCount = 0;
            params[*paramCount].intCount = 0;
            
            while (*p && *p != ']') {
                while (*p == ' ' || *p == ',') p++;
                if (*p == ']') break;
                
                if (*p == '"') {
                    p++;
                    int len = 0;
                    while (*p && *p != '"') {
                        params[*paramCount].stringVals[params[*paramCount].stringCount][len++] = *p++;
                    }
                    params[*paramCount].stringVals[params[*paramCount].stringCount][len] = '\0';
                    params[*paramCount].stringCount++;
                    if (*p == '"') p++;
                } else if ((*p >= '0' && *p <= '9') || *p == '-') {
                    int negative = 0;
                    if (*p == '-') {
                        negative = 1;
                        p++;
                    }
                    int num = 0;
                    while (*p >= '0' && *p <= '9') {
                        num = num * 10 + (*p - '0');
                        p++;
                    }
                    if (negative) num = -num;
                    params[*paramCount].intVals[params[*paramCount].intCount++] = num;
                } else {
                    p++;
                }
            }
            
            if (*p == ']') p++;
            (*paramCount)++;
        } else {
            p++;
        }
    }
}

int main() {
    char line1[100000];
    char line2[100000];
    
    if (fgets(line1, sizeof(line1), stdin) == NULL) {
        printf("[]\n");
        return 0;
    }
    line1[strcspn(line1, "\n\r")] = '\0';
    
    if (fgets(line2, sizeof(line2), stdin) == NULL) {
        printf("[]\n");
        return 0;
    }
    line2[strcspn(line2, "\n\r")] = '\0';
    
    char operations[MAX_OPERATIONS][20];
    int opCount;
    parseStringArray(line1, operations, &opCount);
    
    ParamSet params[MAX_OPERATIONS];
    int paramCount;
    parseParams(line2, params, &paramCount);
    
    TweetCounts* obj = NULL;
    static int results[MAX_OPERATIONS][1000];
    int resultSizes[MAX_OPERATIONS];
    int resultCount = 0;
    
    for (int i = 0; i < opCount; i++) {
        if (strcmp(operations[i], "TweetCounts") == 0) {
            obj = tweetCountsCreate();
            resultSizes[resultCount++] = -1;
        } else if (strcmp(operations[i], "recordTweet") == 0) {
            tweetCountsRecordTweet(obj, params[i].stringVals[0], params[i].intVals[0]);
            resultSizes[resultCount++] = -1;
        } else if (strcmp(operations[i], "getTweetCountsPerFrequency") == 0) {
            int size;
            int* result = tweetCountsGetTweetCountsPerFrequency(obj, params[i].stringVals[0], params[i].stringVals[1], params[i].intVals[0], params[i].intVals[1], &size);
            for (int j = 0; j < size; j++) {
                results[resultCount][j] = result[j];
            }
            resultSizes[resultCount++] = size;
            free(result);
        }
    }
    
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        if (i > 0) printf(",");
        if (resultSizes[i] == -1) {
            printf("null");
        } else {
            printf("[");
            for (int j = 0; j < resultSizes[i]; j++) {
                if (j > 0) printf(",");
                printf("%d", results[i][j]);
            }
            printf("]");
        }
    }
    printf("]\n");
    
    if (obj) free(obj);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × c)

n timestamps scanned × c time chunks per query

⚡ Linearithmic

Space Complexity

O(n)

HashMap storing n tweet timestamps

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

847 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