##### Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/2284.html

# 2284. Sender With Largest Word Count

• Difficulty: Medium.
• Related Topics: Array, Hash Table, String, Counting.
• Similar Questions: Top K Frequent Elements, Top K Frequent Words.

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

Example 1:

Input: messages = ["Hello userTwooo","Hi userThree","Wonderful day Alice","Nice day userThree"], senders = ["Alice","userTwo","userThree","Alice"]
Output: "Alice"
Explanation: 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"
Explanation: 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 (Java, C++, Python)

• class Solution {
public String largestWordCount(String[] messages, String[] senders) {
HashMap<String, Integer> x = new HashMap<>();
for (int i = 0; i < messages.length; i++) {
int words = messages[i].length() - messages[i].replace(" ", "").length() + 1;
if (x.containsKey(senders[i])) {
x.put(senders[i], x.get(senders[i]) + words);
} else {
x.put(senders[i], words);
}
}
String result = "";
int max = 0;
for (Map.Entry<String, Integer> entry : x.entrySet()) {
if (entry.getValue() > max
|| entry.getValue() == max && result.compareTo(entry.getKey()) < 0) {
max = entry.getValue();
result = entry.getKey();
}
}
return result;
}
}

############

class Solution {
public String largestWordCount(String[] messages, String[] senders) {
Map<String, Integer> cnt = new HashMap<>();
int n = senders.length;
for (int i = 0; i < n; ++i) {
int v = 1;
for (int j = 0; j < messages[i].length(); ++j) {
if (messages[i].charAt(j) == ' ') {
++v;
}
}
cnt.merge(senders[i], v, Integer::sum);
}
String ans = senders;
for (var e : cnt.entrySet()) {
String sender = e.getKey();
if (cnt.get(ans) < cnt.get(sender)
|| (cnt.get(ans) == cnt.get(sender) && ans.compareTo(sender) < 0)) {
ans = sender;
}
}
return ans;
}
}

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

############

# 2284. Sender With Largest Word Count
# https://leetcode.com/problems/sender-with-largest-word-count/

class Solution:
def largestWordCount(self, messages: List[str], senders: List[str]) -> str:
mp = defaultdict(int)

for message, sender in zip(messages, senders):
mp[sender] += len(message.split())

currCount = float('-inf')
res = ""

for sender, count in mp.items():
if count > currCount:
currCount = count
res = sender
elif count == currCount:
res = max(res, sender)

return res


• class Solution {
public:
string largestWordCount(vector<string>& messages, vector<string>& senders) {
unordered_map<string, int> cnt;
int n = senders.size();
for (int i = 0; i < n; ++i) {
int v = count(messages[i].begin(), messages[i].end(), ' ') + 1;
cnt[senders[i]] += v;
}
string ans = senders;
for (auto& [sender, v] : cnt) {
if (cnt[ans] < v || (cnt[ans] == v && ans < sender)) {
ans = sender;
}
}
return ans;
}
};

• func largestWordCount(messages []string, senders []string) (ans string) {
cnt := map[string]int{}
for i, msg := range messages {
v := strings.Count(msg, " ") + 1
cnt[senders[i]] += v
}
for sender, v := range cnt {
if cnt[ans] < v || (cnt[ans] == v && ans < sender) {
ans = sender
}
}
return
}


Explain:

nope.

Complexity:

• Time complexity : O(n).
• Space complexity : O(n).