Tweet Counts Per Frequency - Practice Coding Problems

Tweet Counts Per Frequency - Problem

Hash Table String Binary Search Design Sorting Ordered Set Medium

Design a Tweet Analytics System 📊

A social media company needs to monitor activity on their platform by analyzing tweet frequencies over different time periods. Your task is to build an efficient API that can record tweets and query tweet counts across customizable time intervals.

The Challenge: Given a time period [startTime, endTime], partition it into chunks based on frequency:
• "minute": 60-second chunks
• "hour": 3600-second chunks
• "day": 86400-second chunks

Example: Period [10, 10000] seconds:
• Every minute: [10,69], [70,129], [130,189], ..., [9970,10000]
• Every hour: [10,3609], [3610,7209], [7210,10000]
• Every day: [10,10000]

Note: The last chunk may be shorter and always ends at endTime.

Implement:
1. TweetCounts() - Initialize the system
2. recordTweet(tweetName, time) - Record a tweet at given time
3. getTweetCountsPerFrequency(freq, tweetName, startTime, endTime) - Return tweet counts per time chunk

Input & Output

example_1.py — Basic Operations

$ Input: tweetCounts = TweetCounts() tweetCounts.recordTweet("tweet3", 0) tweetCounts.recordTweet("tweet3", 60) tweetCounts.recordTweet("tweet3", 10) tweetCounts.getTweetCountsPerFrequency("minute", "tweet3", 0, 59) tweetCounts.getTweetCountsPerFrequency("minute", "tweet3", 0, 60)

› Output: [2] [2, 1]

💡 Note: For the first query [0, 59], we have one chunk [0, 59] containing tweets at times 0 and 10, so count is 2. For the second query [0, 60], we have chunks [0, 59] and [60, 60], with counts 2 and 1 respectively.

example_2.py — Hour Frequency

$ Input: tweetCounts = TweetCounts() tweetCounts.recordTweet("tweet1", 10) tweetCounts.recordTweet("tweet1", 3610) tweetCounts.recordTweet("tweet1", 7200) tweetCounts.getTweetCountsPerFrequency("hour", "tweet1", 10, 10000)

› Output: [2, 1, 1]

💡 Note: With hour frequency, chunks are [10, 3609], [3610, 7209], [7210, 10000]. Tweet at 10 and 3610 fall in different chunks due to the hour boundary at 3610.

example_3.py — Edge Case Empty

$ Input: tweetCounts = TweetCounts() tweetCounts.getTweetCountsPerFrequency("minute", "nonexistent", 0, 100)

› Output: []

💡 Note: When querying a tweet name that doesn't exist, return an empty list since there are no recorded tweets for that name.

Visualization

Tap to expand

Understanding the Visualization

Record Tweets

As tweets arrive, insert them in sorted order by timestamp for each hashtag

Calculate Time Chunks

Divide the query time period into equal intervals based on frequency (minute/hour/day)

Binary Search Boundaries

For each chunk, use binary search to find first and last tweet in that time range

Count Efficiently

The difference between boundary indices gives the count instantly

Key Takeaway

🎯 Key Insight: By maintaining sorted timestamp arrays and using binary search for range queries, we transform a slow O(k×n) operation into an efficient O(k log n) solution - perfect for real-time social media analytics!

Time & Space Complexity

Time Complexity

⏱️

O(k log n)

For each of k chunks, binary search takes O(log n) time to find range boundaries

⚡ Linearithmic

Space Complexity

O(n)

Store all n tweets in sorted lists within hash map

⚡ Linearithmic Space

Constraints

1 ≤ time, startTime, endTime ≤ 10⁹
0 ≤ (endTime - startTime) ≤ 10⁴
freq is one of "minute", "hour", or "day"
At most 1000 calls will be made to recordTweet and getTweetCountsPerFrequency

Asked in

𝕏 Twitter 85 f Meta 72 G Google 65 a Amazon 58

The optimal solution uses sorted storage with binary search. Store tweets for each name in sorted timestamp order, then use binary search to efficiently find range boundaries for any time chunk. This achieves O(k log n) query time instead of O(k×n) brute force, where k is the number of chunks and n is the number of tweets.

Common Approaches

Approach	Time	Space	Notes
✓ Sorted Storage + Binary Search (Optimal)	O(k log n)	O(n)	Keep tweets sorted by timestamp and use binary search to count ranges efficiently
Brute Force (Linear Search)	O(k*n)	O(n)	Store all tweets and linearly search through each time chunk

Sorted Storage + Binary Search (Optimal) — Algorithm Steps

Store tweets in a hash map where key is tweetName and value is sorted list of timestamps
When recording tweets, insert in sorted order (or sort when needed)
For queries, calculate time chunks based on frequency
For each chunk, use binary search to find left and right boundaries
Count = rightIndex - leftIndex gives tweets in that range
Return counts for all chunks

Visualization

Tap to expand

Step-by-Step Walkthrough

Sorted Storage

Keep tweets sorted by timestamp for fast searching

Binary Search Left

Find first tweet >= startTime of chunk

Binary Search Right

Find first tweet > endTime of chunk

Calculate Count

rightIndex - leftIndex gives count in O(1)

Code -

solution.c — C

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

#define MAX_TWEETS 10000
#define MAX_NAME_LEN 100
#define MAX_NAMES 1000

typedef struct {
    char name[MAX_NAME_LEN];
    int times[MAX_TWEETS];
    int count;
} TwitterData;

typedef struct {
    TwitterData data[MAX_NAMES];
    int nameCount;
} TweetCounts;

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

int findName(TweetCounts* obj, char* tweetName) {
    for (int i = 0; i < obj->nameCount; i++) {
        if (strcmp(obj->data[i].name, tweetName) == 0) {
            return i;
        }
    }
    return -1;
}

void insertSorted(int* arr, int* size, int value) {
    int i;
    for (i = *size - 1; i >= 0 && arr[i] > value; i--) {
        arr[i + 1] = arr[i];
    }
    arr[i + 1] = value;
    (*size)++;
}

void tweetCountsRecordTweet(TweetCounts* obj, char* tweetName, int time) {
    int idx = findName(obj, tweetName);
    if (idx == -1) {
        idx = obj->nameCount++;
        strcpy(obj->data[idx].name, tweetName);
        obj->data[idx].count = 0;
    }
    
    insertSorted(obj->data[idx].times, &obj->data[idx].count, time);
}

int binarySearchLeft(int* arr, int size, int target) {
    int left = 0, right = size;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

int binarySearchRight(int* arr, int size, int target) {
    int left = 0, right = size;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] <= target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

int* tweetCountsGetTweetCountsPerFrequency(TweetCounts* obj, char* freq, char* tweetName, int startTime, int endTime, int* returnSize) {
    int idx = findName(obj, tweetName);
    if (idx == -1) {
        *returnSize = 0;
        return NULL;
    }
    
    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 currentStart = startTime;
    int* times = obj->data[idx].times;
    int timeCount = obj->data[idx].count;
    
    while (currentStart <= endTime) {
        int currentEnd = (currentStart + interval - 1 < endTime) ? currentStart + interval - 1 : endTime;
        
        int leftIdx = binarySearchLeft(times, timeCount, currentStart);
        int rightIdx = binarySearchRight(times, timeCount, currentEnd);
        
        result[(*returnSize)++] = rightIdx - leftIdx;
        currentStart += interval;
        
        if (currentStart > endTime) break;
    }
    
    return result;
}

void tweetCountsFree(TweetCounts* obj) {
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(k log n)

For each of k chunks, binary search takes O(log n) time to find range boundaries

⚡ Linearithmic

Space Complexity

O(n)

Store all n tweets in sorted lists within hash map

⚡ Linearithmic Space

Constraints

1 ≤ time, startTime, endTime ≤ 10⁹
0 ≤ (endTime - startTime) ≤ 10⁴
freq is one of "minute", "hour", or "day"
At most 1000 calls will be made to recordTweet and getTweetCountsPerFrequency

58.2K Views

High Frequency

~25 min Avg. Time

1.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Sorted Storage + Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler