Design Twitter

Design Twitter - Problem

Design a simplified version of Twitter where users can interact through posting tweets, following other users, and viewing personalized news feeds.

Your task is to implement a Twitter class that supports these core social media functionalities:

Post Tweets: Users can compose and publish tweets with unique IDs
Follow/Unfollow: Users can follow or unfollow other users to curate their network
News Feed: Users can retrieve their personalized feed showing the 10 most recent tweets from themselves and users they follow

The news feed should display tweets in chronological order (most recent first), making it feel like a real social media experience!

Class Methods to Implement:

Twitter() - Initialize the Twitter system
postTweet(userId, tweetId) - User posts a tweet
getNewsFeed(userId) - Get 10 most recent tweets for user's feed
follow(followerId, followeeId) - User starts following another user
unfollow(followerId, followeeId) - User unfollows another user

Input & Output

example_1.py — Basic Operations

$ Input: ["Twitter", "postTweet", "getNewsFeed", "follow", "postTweet", "getNewsFeed"] [[], [1, 5], [1], [1, 2], [2, 6], [1]]

› Output: [null, null, [5], null, null, [6, 5]]

💡 Note: User 1 posts tweet 5, gets feed [5]. User 1 follows user 2. User 2 posts tweet 6. User 1's feed now shows [6, 5] - both their own tweet and their followee's tweet in chronological order.

example_2.py — Multiple Users and Tweets

$ Input: ["Twitter", "postTweet", "postTweet", "postTweet", "getNewsFeed", "follow", "getNewsFeed"] [[], [1, 1], [2, 2], [1, 3], [1], [1, 2], [1]]

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

💡 Note: Multiple users post tweets. User 1's initial feed shows only their tweets [3, 1]. After following user 2, the feed includes user 2's tweets: [3, 2, 1].

example_3.py — Unfollow Operation

$ Input: ["Twitter", "postTweet", "follow", "postTweet", "getNewsFeed", "unfollow", "getNewsFeed"] [[], [1, 1], [1, 2], [2, 2], [1], [1, 2], [1]]

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

💡 Note: User 1 follows user 2 and sees both tweets [2, 1]. After unfollowing user 2, the feed only shows user 1's own tweets [1].

Constraints

1 ≤ userId, followerId, followeeId ≤ 500
0 ≤ tweetId ≤ 10⁴
All the tweets have unique IDs
At most 3 × 10⁴ calls will be made to the functions

Visualization

Tap to expand

Asked in

f Meta 45 T Twitter 38 G Google 32 a Amazon 28

The optimal solution uses hash maps for O(1) user lookups and heaps for efficient top-k tweet retrieval. Key insights: maintain chronological ordering with timestamps, use sets for following relationships, and leverage priority queues to avoid sorting all tweets for each news feed request.

Common Approaches

✓ Memoization

⏱️ Time: N/A Space: N/A

Dp 2d

⏱️ Time: N/A Space: N/A

Hash Map + Heap (Optimal)

⏱️ Time: O(k log m) Space: O(n + m)

Optimize the solution by using hash maps to store user data and tweets, and employ a heap (priority queue) to efficiently retrieve the top 10 most recent tweets without sorting all tweets every time.

Brute Force (Linear Search)

⏱️ Time: O(n * m * log(nm)) Space: O(n * m)

Store tweets in simple lists and for each news feed request, iterate through all tweets from the user and their followees, then sort to get the most recent ones.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

const int MOD = 1000000007;
int memo[5001][7][16]; // n, lastNum, consecutiveCount
int memo_set[5001][7][16];

int dfs(int pos, int lastNum, int consecutiveCount, int n, int* rollMax) {
    if (pos == n) {
        return 1;
    }
    
    if (memo_set[pos][lastNum][consecutiveCount]) {
        return memo[pos][lastNum][consecutiveCount];
    }
    
    long long total = 0;
    for (int num = 1; num <= 6; num++) {
        if (lastNum == 0) {  // First roll
            total = (total + dfs(pos + 1, num, 1, n, rollMax)) % MOD;
        } else if (num == lastNum) {
            if (consecutiveCount < rollMax[num - 1]) {
                total = (total + dfs(pos + 1, num, consecutiveCount + 1, n, rollMax)) % MOD;
            }
        } else {
            total = (total + dfs(pos + 1, num, 1, n, rollMax)) % MOD;
        }
    }
    
    memo[pos][lastNum][consecutiveCount] = (int) total;
    memo_set[pos][lastNum][consecutiveCount] = 1;
    return (int) total;
}

int solution(int n, int* rollMax) {
    memset(memo_set, 0, sizeof(memo_set));
    return dfs(0, 0, 0, n, rollMax);
}

int main() {
    int n;
    scanf("%d", &n);
    
    int rollMax[6];
    char buffer[100];
    scanf(" %s", buffer);
    
    // Parse [1,1,2,2,2,3] format
    char* ptr = buffer + 1; // skip '['
    for (int i = 0; i < 6; i++) {
        rollMax[i] = strtol(ptr, &ptr, 10);
        if (*ptr == ',') ptr++;
    }
    
    int result = solution(n, rollMax);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

64.8K Views

High Frequency

~25 min Avg. Time

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