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)

• Java
• Python
• C++
• Go

• 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[0];
          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[0];
          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).

All Problems

All Solutions