Design Twitter - Practice Coding Problems

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].

Visualization

Tap to expand

Understanding the Visualization

Data Storage

Hash maps store user tweets and following relationships for O(1) access

Tweet Posting

New tweets are appended with timestamps for chronological ordering

News Feed Generation

Heap efficiently merges and selects top 10 tweets from multiple sources

Follow Management

Set operations handle follow/unfollow with no duplicates

Key Takeaway

🎯 Key Insight: Combining hash maps for O(1) access with heaps for efficient top-k selection creates a scalable social media system that handles real-time feeds efficiently.

Time & Space Complexity

Time Complexity

⏱️

O(k log m)

k = number of followees, m = tweets per user, log m for heap operations

⚡ Linearithmic

Space Complexity

O(n + m)

n = number of users, m = total tweets stored

⚡ Linearithmic Space

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

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

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(n * m * log(nm))	O(n * m)	Store all tweets in lists and search through all tweets for each news feed request
Hash Map + Heap (Optimal)	O(k log m)	O(n + m)	Use hash maps for O(1) lookups and a max heap to efficiently get top 10 tweets

Brute Force (Linear Search) — Algorithm Steps

Store all tweets in a simple list structure
For each getNewsFeed request, collect all tweets from user and followees
Sort collected tweets by timestamp/order
Return the 10 most recent tweets

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect User Tweets

Gather all tweets from the requesting user

Collect Followee Tweets

Iterate through all followees and collect their tweets

Sort All Tweets

Sort the combined tweet list by timestamp

Return Top 10

Return the 10 most recent tweets

Code -

solution.c — C

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

#define MAX_USERS 1000
#define MAX_TWEETS 10000

typedef struct {
    int timestamp;
    int tweetId;
} Tweet;

typedef struct {
    Tweet tweets[MAX_TWEETS];
    int tweetCount;
    int following[MAX_USERS];
    int followingCount;
} User;

typedef struct {
    User users[MAX_USERS];
    int timestamp;
} Twitter;

Twitter* twitterCreate() {
    Twitter* obj = (Twitter*)calloc(1, sizeof(Twitter));
    return obj;
}

void twitterPostTweet(Twitter* obj, int userId, int tweetId) {
    User* user = &obj->users[userId];
    user->tweets[user->tweetCount].timestamp = obj->timestamp++;
    user->tweets[user->tweetCount].tweetId = tweetId;
    user->tweetCount++;
}

int compare(const void* a, const void* b) {
    Tweet* ta = (Tweet*)a;
    Tweet* tb = (Tweet*)b;
    return tb->timestamp - ta->timestamp;
}

int* twitterGetNewsFeed(Twitter* obj, int userId, int* returnSize) {
    Tweet allTweets[MAX_TWEETS];
    int count = 0;
    
    // Add user's own tweets
    User* user = &obj->users[userId];
    for (int i = 0; i < user->tweetCount; i++) {
        allTweets[count++] = user->tweets[i];
    }
    
    // Add tweets from followees
    for (int i = 0; i < user->followingCount; i++) {
        int followeeId = user->following[i];
        User* followee = &obj->users[followeeId];
        for (int j = 0; j < followee->tweetCount; j++) {
            allTweets[count++] = followee->tweets[j];
        }
    }
    
    // Sort by timestamp
    qsort(allTweets, count, sizeof(Tweet), compare);
    
    // Return top 10
    int* result = (int*)malloc(10 * sizeof(int));
    *returnSize = count < 10 ? count : 10;
    for (int i = 0; i < *returnSize; i++) {
        result[i] = allTweets[i].tweetId;
    }
    return result;
}

void twitterFollow(Twitter* obj, int followerId, int followeeId) {
    if (followerId != followeeId) {
        User* user = &obj->users[followerId];
        // Check if already following
        for (int i = 0; i < user->followingCount; i++) {
            if (user->following[i] == followeeId) return;
        }
        user->following[user->followingCount++] = followeeId;
    }
}

void twitterUnfollow(Twitter* obj, int followerId, int followeeId) {
    User* user = &obj->users[followerId];
    for (int i = 0; i < user->followingCount; i++) {
        if (user->following[i] == followeeId) {
            // Shift remaining elements
            for (int j = i; j < user->followingCount - 1; j++) {
                user->following[j] = user->following[j + 1];
            }
            user->followingCount--;
            break;
        }
    }
}

void twitterFree(Twitter* obj) {
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m * log(nm))

n users, m tweets per user, sorting required for each getNewsFeed call

⚡ Linearithmic

Space Complexity

O(n * m)

Store all tweets for all users

⚡ Linearithmic Space

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

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler