Sender With Largest Word Count

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

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

✓ Brute Force

⏱️ Time: O(n×k) Space: O(k)

First collect all unique senders, then for each sender, scan through all messages to count words from that sender. Finally compare all counts to find the maximum.

Hash Map Frequency Count

⏱️ Time: O(n) Space: O(k)

Iterate through messages once, counting words for each message and adding to the corresponding sender's total in a hash map. Then find the sender with maximum count.

Single Pass with Tracking

⏱️ Time: O(n) Space: O(k)

Combine counting and maximum finding into one pass. As we count words for each sender, immediately check if they become the new leader, handling lexicographic ties on the spot.

Brute Force — Algorithm Steps

Step 1: Find all unique senders
Step 2: For each sender, scan all messages and count words
Step 3: Find sender with maximum word count, breaking ties lexicographically

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Unique Senders

Extract all unique sender names

Count Per Sender

For each sender, scan all messages to count words

Find Maximum

Compare counts and select winner with lexicographic tiebreaker

Code -

solution.c — C

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

static char senderNames[1000][100];
static int wordCounts[1000];
static int senderCount = 0;

char* solution(char** messages, int messagesSize, char** senders, int sendersSize) {
    senderCount = 0;
    
    // Count words for each sender
    for (int i = 0; i < messagesSize; i++) {
        char* sender = senders[i];
        
        // Find or create sender entry
        int senderIndex = -1;
        for (int j = 0; j < senderCount; j++) {
            if (strcmp(senderNames[j], sender) == 0) {
                senderIndex = j;
                break;
            }
        }
        
        if (senderIndex == -1) {
            strcpy(senderNames[senderCount], sender);
            wordCounts[senderCount] = 0;
            senderIndex = senderCount++;
        }
        
        // Count words in message
        char* msgCopy = malloc(strlen(messages[i]) + 1);
        strcpy(msgCopy, messages[i]);
        
        int words = 0;
        char* token = strtok(msgCopy, " ");
        while (token != NULL) {
            words++;
            token = strtok(NULL, " ");
        }
        
        wordCounts[senderIndex] += words;
        free(msgCopy);
    }
    
    // Find sender with max word count, with lexicographical tie-breaking
    int maxCount = 0;
    for (int i = 0; i < senderCount; i++) {
        if (wordCounts[i] > maxCount) {
            maxCount = wordCounts[i];
        }
    }
    
    char* result = malloc(100);
    strcpy(result, "");
    
    for (int i = 0; i < senderCount; i++) {
        if (wordCounts[i] == maxCount) {
            if (strlen(result) == 0 || strcmp(senderNames[i], result) > 0) {
                strcpy(result, senderNames[i]);
            }
        }
    }
    
    return result;
}

void parseStringArray(const char* input, char** output, int* size) {
    *size = 0;
    char* copy = malloc(strlen(input) + 1);
    strcpy(copy, input);
    
    char* p = copy;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p && (*p == ' ' || *p == ',')) p++;
        if (*p == ']' || *p == '\0') break;
        
        if (*p == '"') p++; // Skip opening quote
        char* start = p;
        while (*p && *p != '"') p++; // Find closing quote
        if (*p == '"') {
            *p = '\0';
            output[(*size)] = malloc(strlen(start) + 1);
            strcpy(output[(*size)], start);
            (*size)++;
            p++;
        }
    }
    
    free(copy);
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    char* messages[1000];
    char* senders[1000];
    int messagesSize, sendersSize;
    
    parseStringArray(line1, messages, &messagesSize);
    parseStringArray(line2, senders, &sendersSize);
    
    char* result = solution(messages, messagesSize, senders, sendersSize);
    printf("%s\n", result);
    
    // Free allocated memory
    for (int i = 0; i < messagesSize; i++) free(messages[i]);
    for (int i = 0; i < sendersSize; i++) free(senders[i]);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×k)

For each of k unique senders, we scan all n messages

✓ Linear Growth

Space Complexity

O(k)

Store unique senders in a set

✓ 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

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler