#2284

Medium

auto_awesomeArray scanning plus hash lookup

LeetCode Problem Workspace

Sender With Largest Word Count

Find the sender with the largest total word count by scanning messages and tallying counts using a hash table efficiently.

array hash table string counting

Problem Statement

You are given two arrays of strings: messages and senders. Each messages[i] is a single message sent by senders[i]. Messages contain words separated by single spaces with no leading or trailing spaces.

Calculate the total number of words each sender has sent. Return the sender with the largest word count. If multiple senders share the largest count, return the sender with the lexicographically largest name.

Examples

Example 1

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

Output: "Alice"

Alice sends a total of 2 + 3 = 5 words. userTwo sends a total of 2 words. userThree sends a total of 3 words. Since Alice has the largest word count, we return "Alice".

Example 2

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

Output: "Charlie"

Bob sends a total of 5 words. Charlie sends a total of 5 words. Since there is a tie for the largest word count, we return the sender with the lexicographically larger name, Charlie.

Constraints

n == messages.length == senders.length
1 <= n <= 104
1 <= messages[i].length <= 100
1 <= senders[i].length <= 10
messages[i] consists of uppercase and lowercase English letters and ' '.
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.

Solution Approach

Count Words Per Sender

Iterate through messages, split each message by spaces to determine word count, and update a hash table mapping senders to their cumulative word counts.

Determine Maximum Sender

Traverse the hash table entries to find the sender with the highest word count. In case of ties, compare sender names lexicographically and select the largest.

Return the Result

After scanning all entries, return the sender identified as having the largest word count, reflecting correct handling of tie-breakers and array scanning plus hash lookup logic.

Complexity Analysis

Metric	Value
Time	Depends on the final approach
Space	Depends on the final approach

Time complexity is O(n * m) where n is the number of messages and m is the average number of words per message due to splitting. Space complexity is O(k) for storing counts per sender, with k being the number of unique senders.

What Interviewers Usually Probe

Focus on efficient word counting with split operations and hash table aggregation.
Tie-breaking logic using lexicographical comparison is a critical detail.
Expect attention to cumulative counts across multiple messages per sender.

Common Pitfalls or Variants

Common pitfalls

Failing to correctly count words by misinterpreting spaces or not handling multiple messages per sender.
Ignoring tie-breakers and returning the first maximum instead of lexicographically largest.
Updating counts incorrectly in the hash table, overwriting instead of accumulating.

Follow-up variants

Return the sender with the smallest word count instead of the largest.
Identify multiple senders with the top word count and return them in a sorted array.
Handle messages containing punctuation or multiple consecutive spaces requiring custom splitting logic.

FAQ

How do I count words efficiently in Sender With Largest Word Count?

Use string split by space and sum lengths per sender in a hash table for O(n * m) processing.

What if multiple senders have the same maximum word count?

Select the sender with the lexicographically largest name as the tie-breaker according to problem rules.

Does the order of messages matter for the result?

No, the total word count per sender is cumulative and independent of message order.

Can I optimize space usage for many senders?

Yes, only store counts for unique senders in the hash table, which reduces memory for large n.

What is the key pattern for solving this problem?

The main pattern is array scanning plus hash lookup, counting words per sender while updating totals efficiently.

terminal

Solution

Solution 1: Hash Table + Enumeration

We can use a hash table $\textit{cnt}$ to record the word count for each sender. Then, we traverse the hash table to find the sender with the highest word count. If there are multiple senders with the highest word count, we return the name that is lexicographically largest.

1

2

3

4

5

6

7

8

9

10

class Solution:
    def largestWordCount(self, messages: List[str], senders: List[str]) -> str:
        cnt = Counter()
        for message, sender in zip(messages, senders):
            cnt[sender] += message.count(" ") + 1
        ans = senders[0]
        for k, v in cnt.items():
            if cnt[ans] < v or (cnt[ans] == v and ans < k):
                ans = k
        return ans

Continue Practicing

#2131 longest palindrome by concatenating two letter words #2085 count common words with one occurrence #2506 count pairs of similar strings