Sender With Largest Word Count - Practice Coding Problems

Sender With Largest Word Count - Problem

You have a chat log of n messages. You are given two string arrays messages and senders where messages[i] is a message sent by senders[i].

A message is a list of words that are separated by a single space with no leading or trailing spaces. The word count of a sender is the total number of words sent by the sender. Note that a sender may send more than one message.

Return the sender with the largest word count. If there is more than one sender with the largest word count, return the one with the lexicographically largest name.

Note:

Uppercase letters come before lowercase letters in lexicographical order.
"Alice" and "alice" are distinct.

Input & Output

Example 1 — Basic Case

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

› Output: Alice

💡 Note: Alice sends "Hello userTwooo" (2 words) + "Wonderful day Alice" (3 words) = 5 words. Bob sends "Hi userThree" (2 words) + "Nice day userThree" (3 words) = 5 words. Since both have 5 words, return lexicographically largest: "Alice" > "Bob", so Alice wins.

Example 2 — Clear Winner

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

› Output: Bob

💡 Note: Bob sends 5 words, Alice sends 5 words. Both tied at 5 words. "Bob" > "Alice" lexicographically, so Bob wins.

Example 3 — Multiple Messages

$ Input: messages = ["a", "bb", "ccc"], senders = ["Alice", "Alice", "Bob"]

› Output: Alice

💡 Note: Alice sends "a" (1 word) + "bb" (1 word) = 2 words. Bob sends "ccc" (1 word) = 1 word. Alice has more words: 2 > 1.

Constraints

1 ≤ messages.length ≤ 10⁴
1 ≤ messages[i].length ≤ 100
1 ≤ senders[i].length ≤ 20
messages[i] consists of lowercase English letters and ' ' (space)
All the words in messages[i] are separated by a single space
messages[i] does not have leading or trailing spaces
senders[i] consists of uppercase and lowercase English letters only

Visualization

Tap to expand

Understanding the Visualization

Input

Array of messages and corresponding senders

Process

Count words per sender using hash map

Output

Return sender with maximum word count (lexicographic tiebreaker)

Key Takeaway

🎯 Key Insight: Use hash map to accumulate word counts per sender, then find maximum with lexicographic tiebreaker

Asked in

f Meta 12 a Amazon 8 G Google 6

The key insight is to use a hash map to count words per sender in a single pass, then find the sender with maximum count using lexicographic comparison for ties. Best approach is the optimized single-pass tracking which combines counting and winner tracking. Time: O(n), Space: O(k) where k is unique senders.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass with Tracking	O(n)	O(k)	Track maximum count and winner during the single pass to avoid second iteration
Hash Map Frequency Count	O(n)	O(k)	Single pass through messages, using hash map to accumulate word counts per sender
Brute Force	O(n×k)	O(k)	For each unique sender, iterate through all messages to count their total words

Single Pass with Tracking — Algorithm Steps

Step 1: Initialize hash map and tracking variables
Step 2: For each message, update sender's count and check if they're the new leader
Step 3: Return the tracked winner

Visualization

Tap to expand

Step-by-Step Walkthrough

Process & Track

Update counts and winner simultaneously

Real-time Updates

Winner changes as new maximums are found

Final Winner

No additional pass needed

Code -

solution.c — C

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

char* solution(char** messages, int messagesSize, char** senders, int sendersSize) {
    char senderNames[1000][100];
    int wordCounts[1000];
    int uniqueCount = 0;
    int maxCount = 0;
    char* result = malloc(100);
    strcpy(result, "");
    
    for (int i = 0; i < messagesSize; i++) {
        char* sender = senders[i];
        
        // Count words in message
        int wordCount = 0;
        char* copy = strdup(messages[i]);
        char* token = strtok(copy, " ");
        while (token != NULL) {
            wordCount++;
            token = strtok(NULL, " ");
        }
        free(copy);
        
        // Find or create sender entry
        int senderIndex = -1;
        for (int j = 0; j < uniqueCount; j++) {
            if (strcmp(senderNames[j], sender) == 0) {
                senderIndex = j;
                break;
            }
        }
        
        int newCount;
        if (senderIndex == -1) {
            strcpy(senderNames[uniqueCount], sender);
            wordCounts[uniqueCount] = wordCount;
            newCount = wordCount;
            uniqueCount++;
        } else {
            wordCounts[senderIndex] += wordCount;
            newCount = wordCounts[senderIndex];
        }
        
        // Update maximum if this sender is now leading
        if (newCount > maxCount || (newCount == maxCount && strcmp(sender, result) > 0)) {
            maxCount = newCount;
            strcpy(result, sender);
        }
    }
    
    return result;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through n messages with constant time hash operations

✓ Linear Growth

Space Complexity

O(k)

Hash map stores k unique senders plus constant tracking variables

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

485 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

Constraints

Visualization

Related Problems

Common Approaches

Single Pass with Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler