Sender With Largest Word Count - Practice Coding Problems

Sender With Largest Word Count - Problem

Imagine you're analyzing a busy chat room where multiple users are having conversations! 💬

You have a chat log containing n messages. You're given two string arrays: messages and senders, where messages[i] is a message sent by senders[i].

Your task: Find the sender who has sent the most words across all their messages!

Key details:

Each message is a list of words separated by single spaces (no leading/trailing spaces)
A sender's word count is the total number of words across all their messages
If there's a tie, return the sender with the lexicographically largest name
Remember: Uppercase letters come before lowercase in lexicographical order, so "Alice" ≠ "alice"

Example: If Alice sends "Hello world" and "Good morning", her word count is 4 words total.

Input & Output

example_1.py — Basic Case

$ Input: messages = ["Hello userTwooo", "Hi userThree", "Wonderful day Alice", "Nice day userThree"] senders = ["Alice", "Bob", "Alice", "Bob"]

› Output: "Alice"

💡 Note: Alice sent "Hello userTwooo" (2 words) and "Wonderful day Alice" (3 words) = 5 total words. Bob sent "Hi userThree" (2 words) and "Nice day userThree" (3 words) = 5 total words. Since both have 5 words, we return "Alice" because "Alice" > "Bob" lexicographically.

example_2.py — Clear Winner

$ Input: messages = ["How is leetcode for everyone", "Leetcode is useful for practice"] senders = ["Bob", "Charlie"]

› Output: "Charlie"

💡 Note: Bob sent 5 words, Charlie sent 5 words. Since it's a tie, we compare lexicographically: "Charlie" > "Bob", so Charlie wins.

example_3.py — Single Word Messages

$ Input: messages = ["Hello", "Hi", "Hey"] senders = ["Alice", "Alice", "Bob"]

› Output: "Alice"

💡 Note: Alice sent 2 messages with 1 word each = 2 total words. Bob sent 1 message with 1 word = 1 total word. Alice has more words, so she wins.

Visualization

Tap to expand

Understanding the Visualization

Read Messages

Process each chat message one by one, identifying sender and counting words

Update Scoreboard

Add word count to sender's running total in our hash table scoreboard

Track Leader

After each update, check if current sender is the new champion

Handle Ties

When word counts are equal, the lexicographically larger name wins

Key Takeaway

🎯 Key Insight: By processing messages in a single pass and maintaining both the word count hash map and current winner simultaneously, we achieve optimal O(n) time complexity while handling lexicographical tie-breaking elegantly.

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Single pass through n messages, plus m total words to count across all messages

✓ Linear Growth

Space Complexity

O(k)

Hash map space for k unique senders, typically much smaller than n

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁴ where n is the number of messages
1 ≤ messages[i].length, senders[i].length ≤ 100
messages[i] consists of lowercase English letters and spaces
senders[i] consists of uppercase and lowercase English letters
All messages[i] are non-empty and do not have leading or trailing spaces
All words in messages[i] are separated by a single space

Asked in

G Google 23 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses a one-pass hash table approach with O(n) time complexity. As we process each message, we count words and update the sender's total while simultaneously tracking the current winner. This eliminates the need for separate counting and searching phases, making it highly efficient for large datasets.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n + m)	O(k)	Build word count map and track the winner simultaneously in single pass
Brute Force (Nested Loops)	O(n²)	O(n)	For each unique sender, scan all messages to count their total words

One-Pass Hash Table (Optimal) — Algorithm Steps

Initialize hash map for word counts and variables for tracking maximum
For each message, count words and add to sender's total in hash map
After updating word count, check if current sender is new winner
Handle lexicographical comparison for ties
Return the winner after single pass through messages

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Message

Count words and update sender's total in hash map

Update Winner

Check if current sender is new leader

Continue

Move to next message, maintaining current best

Code -

solution.c — C

char* largestWordCount(char** messages, int messagesSize, char** senders, int sendersSize, int* returnSize) {
    // Simple hash table implementation using arrays
    char senderNames[1000][21];
    int wordCounts[1000];
    int hashSize = 0;
    
    int maxWords = 0;
    char* result = (char*)malloc(21 * sizeof(char));
    strcpy(result, "");
    
    for (int i = 0; i < messagesSize; i++) {
        char* sender = senders[i];
        
        // Count words in message
        char* msg = (char*)malloc(strlen(messages[i]) + 1);
        strcpy(msg, messages[i]);
        int words = 0;
        char* token = strtok(msg, " ");
        while (token != NULL) {
            words++;
            token = strtok(NULL, " ");
        }
        free(msg);
        
        // Find or create sender in hash table
        int senderIndex = -1;
        for (int j = 0; j < hashSize; j++) {
            if (strcmp(senderNames[j], sender) == 0) {
                senderIndex = j;
                break;
            }
        }
        
        if (senderIndex == -1) {
            senderIndex = hashSize++;
            strcpy(senderNames[senderIndex], sender);
            wordCounts[senderIndex] = 0;
        }
        
        // Update word count
        wordCounts[senderIndex] += words;
        int currentTotal = wordCounts[senderIndex];
        
        // Check if winner
        if (currentTotal > maxWords || (currentTotal == maxWords && strcmp(sender, result) > 0)) {
            maxWords = currentTotal;
            strcpy(result, sender);
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Single pass through n messages, plus m total words to count across all messages

✓ Linear Growth

Space Complexity

O(k)

Hash map space for k unique senders, typically much smaller than n

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁴ where n is the number of messages
1 ≤ messages[i].length, senders[i].length ≤ 100
messages[i] consists of lowercase English letters and spaces
senders[i] consists of uppercase and lowercase English letters
All messages[i] are non-empty and do not have leading or trailing spaces
All words in messages[i] are separated by a single space

28.3K Views

Medium Frequency

~15 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler