Count Mentions Per User - Practice Coding Problems

Count Mentions Per User - Problem

Imagine you're building a chat monitoring system for a social platform! Your task is to track how many times each user gets mentioned across all messages.

You're given numberOfUsers representing the total number of users and an array events containing two types of events:

📨 Message Events

["MESSAGE", "timestamp", "mentions_string"] - A message was sent at the given timestamp with mentions. The mentions can be:

id<number> - Mentions specific user ID (e.g., "id0 id2 id0" mentions user 0 twice and user 2 once)
ALL - Mentions every single user
HERE - Mentions only currently online users

🔌 Offline Events

["OFFLINE", "timestamp", "user_id"] - User goes offline for exactly 60 time units (returns online at timestamp + 60)

Goal: Return an array where result[i] = total mentions for user i across all MESSAGE events.

Note: All users start online, and status changes are processed before messages at the same timestamp.

Input & Output

example_1.py — Basic mentions

$ Input: numberOfUsers = 3, events = [["MESSAGE","10","id0 id1"],["MESSAGE","20","ALL"],["MESSAGE","30","HERE"]]

› Output: [3, 3, 2]

💡 Note: User 0: mentioned in first message (id0), second message (ALL), and third message (HERE) = 3 times. User 1: mentioned in first message (id1), second message (ALL), and third message (HERE) = 3 times. User 2: mentioned in second message (ALL) and third message (HERE) = 2 times.

example_2.py — With offline users

$ Input: numberOfUsers = 2, events = [["OFFLINE","5","0"],["MESSAGE","10","HERE"],["MESSAGE","70","HERE"]]

› Output: [1, 2]

💡 Note: User 0 goes offline at T=5 and comes back at T=65. First HERE message at T=10 only mentions user 1 (user 0 is offline). Second HERE message at T=70 mentions both users (user 0 is back online). Result: User 0 gets 1 mention, User 1 gets 2 mentions.

example_3.py — Duplicate mentions

$ Input: numberOfUsers = 2, events = [["MESSAGE","10","id0 id0 id1"]]

› Output: [2, 1]

💡 Note: The message "id0 id0 id1" mentions user 0 twice and user 1 once. Each mention is counted separately, so user 0 gets 2 mentions and user 1 gets 1 mention.

Visualization

Tap to expand

Understanding the Visualization

Timeline Setup

Sort all events chronologically to process them in the order they actually happened

Status Tracking

Keep track of when each user will return from their coffee break (offline + 60 minutes)

Message Processing

For each announcement, count mentions: ALL (everyone), HERE (present staff), or specific names

Final Count

Accumulate all mentions for each user across the entire timeline

Key Takeaway

🎯 Key Insight: Instead of recalculating who's online for every message (O(n²)), we maintain a smart mapping of when users return online, making the solution optimal at O(n log n) time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n log n + m)

O(n log n) for sorting events, O(m) for processing all mention tokens across all messages

⚡ Linearithmic

Space Complexity

O(n + u)

O(n) for offline tracking data structures, O(u) for result array where u = numberOfUsers

⚡ Linearithmic Space

Constraints

1 ≤ numberOfUsers ≤ 10⁵
0 ≤ events.length ≤ 10⁵
Each event has exactly 3 elements
0 ≤ timestamp_i ≤ 10⁹
For OFFLINE events: 0 ≤ user_id ≤ numberOfUsers - 1
mentions_string contains only valid tokens separated by single spaces
Status changes are processed before messages at the same timestamp

Asked in

f Meta 45 G Google 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses chronological event processing with efficient online status tracking. We sort events by timestamp and maintain a map of when offline users return online. For each MESSAGE event, we quickly determine online users and count mentions based on ALL/HERE/specific ID patterns. This achieves O(n log n) time complexity, making it scalable for large inputs.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Process Each Event Separately)	O(n²)	O(n)	For each message event, recalculate online users from scratch
One-Pass Simulation (Optimal)	O(n log n + m)	O(n + u)	Process events chronologically while maintaining online status efficiently

Brute Force (Process Each Event Separately) — Algorithm Steps

Sort all events by timestamp
For each MESSAGE event, scan all OFFLINE events to determine online users
Parse mentions string and count mentions for each user
Handle ALL, HERE, and specific ID mentions separately
Accumulate counts in result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Events

Sort all events by timestamp chronologically

Process Message

For each MESSAGE event, scan all OFFLINE events to determine who's online

Count Mentions

Parse mentions string and increment counters based on ALL/HERE/specific IDs

Code -

solution.c — C

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

typedef struct {
    char type[10];
    int timestamp;
    char data[1000];
} Event;

int compareEvents(const void* a, const void* b) {
    Event* eventA = (Event*)a;
    Event* eventB = (Event*)b;
    return eventA->timestamp - eventB->timestamp;
}

int* solution(int numberOfUsers, Event* events, int eventCount) {
    // Sort events by timestamp
    qsort(events, eventCount, sizeof(Event), compareEvents);
    
    int* mentions = (int*)calloc(numberOfUsers, sizeof(int));
    
    for (int i = 0; i < eventCount; i++) {
        if (strcmp(events[i].type, "MESSAGE") == 0) {
            int timestamp = events[i].timestamp;
            char* mentionsStr = events[i].data;
            
            // Determine who's online at this timestamp (brute force)
            int* online = (int*)malloc(numberOfUsers * sizeof(int));
            for (int j = 0; j < numberOfUsers; j++) {
                online[j] = 1;
            }
            
            for (int j = 0; j < eventCount; j++) {
                if (strcmp(events[j].type, "OFFLINE") == 0) {
                    int offlineTime = events[j].timestamp;
                    int userId = atoi(events[j].data);
                    if (offlineTime <= timestamp && timestamp < offlineTime + 60) {
                        online[userId] = 0;
                    }
                }
            }
            
            // Process mentions
            if (strcmp(mentionsStr, "ALL") == 0) {
                for (int j = 0; j < numberOfUsers; j++) {
                    mentions[j]++;
                }
            } else if (strcmp(mentionsStr, "HERE") == 0) {
                for (int j = 0; j < numberOfUsers; j++) {
                    if (online[j]) {
                        mentions[j]++;
                    }
                }
            } else {
                // Parse specific user mentions
                char* token = strtok(mentionsStr, " ");
                while (token != NULL) {
                    if (strncmp(token, "id", 2) == 0) {
                        int userId = atoi(token + 2);
                        if (userId >= 0 && userId < numberOfUsers) {
                            mentions[userId]++;
                        }
                    }
                    token = strtok(NULL, " ");
                }
            }
            
            free(online);
        }
    }
    
    return mentions;
}

int main() {
    int numberOfUsers;
    Event events[1000];
    int eventCount;
    
    // Parse input and call solution
    int* result = solution(numberOfUsers, events, eventCount);
    
    for (int i = 0; i < numberOfUsers; i++) {
        printf("%d%s", result[i], i == numberOfUsers - 1 ? "\n" : " ");
    }
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n events, we potentially scan all n events to determine online status

⚠ Quadratic Growth

Space Complexity

O(n)

Space for result array and temporary storage for parsing mentions

⚡ Linearithmic Space

Constraints

1 ≤ numberOfUsers ≤ 10⁵
0 ≤ events.length ≤ 10⁵
Each event has exactly 3 elements
0 ≤ timestamp_i ≤ 10⁹
For OFFLINE events: 0 ≤ user_id ≤ numberOfUsers - 1
mentions_string contains only valid tokens separated by single spaces
Status changes are processed before messages at the same timestamp

43.2K Views

Medium-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

📨 Message Events

🔌 Offline Events

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Process Each Event Separately) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler