Most Common Word

Most Common Word - Problem

Given a string paragraph and a string array of the banned words, return the most frequent word that is not banned.

It is guaranteed there is at least one word that is not banned, and that the answer is unique.

The words in paragraph are case-insensitive and the answer should be returned in lowercase.

Note: Words cannot contain punctuation symbols.

Input & Output

Example 1 — Basic Case

$ Input: paragraph = "Bob hit a ball, the hit BALL flew far after it was hit.", banned = ["hit"]

› Output: "ball"

💡 Note: "hit" appears 3 times but is banned. "ball" appears 2 times (case-insensitive: "ball", "BALL") and is not banned, making it the most frequent valid word.

Example 2 — Multiple Banned Words

$ Input: paragraph = "a, a, a, a, b,b,b,c, c", banned = ["a"]

› Output: "b"

💡 Note: "a" appears 4 times but is banned. "b" appears 3 times and "c" appears 2 times. "b" is the most frequent non-banned word.

Example 3 — Case Insensitive

$ Input: paragraph = "Bob bob BOB", banned = []

› Output: "bob"

💡 Note: "Bob", "bob", and "BOB" are the same word (case-insensitive). "bob" appears 3 times and no words are banned.

Constraints

1 ≤ paragraph.length ≤ 1000
paragraph consists of English letters, space ' ', or one of the symbols: "!?',;."
0 ≤ banned.length ≤ 100
1 ≤ banned[i].length ≤ 10
banned[i] consists of only lowercase English letters

Visualization

Tap to expand

Asked in

A Amazon 45 🍎 Apple 32 G Google 28 F Facebook 21

The key insight is to use hash maps for both frequency counting and banned word filtering. Extract words using regex, count frequencies while skipping banned words, then find the maximum. Best approach is single pass with immediate filtering for optimal performance. Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force - Manual Word Processing

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

Process the paragraph character by character to extract words, then for each word count its total occurrences by scanning the entire text again, while checking if it's banned.

Hash Map Frequency Count

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

Clean the paragraph to extract words, use a hash map to count frequency of each word in one pass, then iterate through the frequency map to find the word with maximum count that's not in the banned set.

Single Pass with Immediate Filtering

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

Optimize by checking if a word is banned immediately when we encounter it during parsing, so we never store banned words in our frequency map. This saves both time and space.

Brute Force - Manual Word Processing — Algorithm Steps

Extract all words by iterating through each character
For each unique word, scan entire text again to count occurrences
Skip banned words and find the word with maximum count

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Words

Split paragraph into individual words

Count Each

For each unique word, scan entire text to count occurrences

Find Maximum

Return non-banned word with highest count

Code -

solution.c — C

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

#define MAX_WORDS 1000
#define MAX_WORD_LEN 100
#define MAX_TEXT_LEN 10000

static char words[MAX_WORDS][MAX_WORD_LEN];
static int frequencies[MAX_WORDS];

char* solution(char* paragraph, char banned[][MAX_WORD_LEN], int bannedSize) {
    int wordCount = 0;
    
    // Extract words
    int len = strlen(paragraph);
    int wordStart = -1;
    
    for (int i = 0; i <= len; i++) {
        if (i < len && isalpha(paragraph[i])) {
            if (wordStart == -1) wordStart = i;
        } else {
            if (wordStart != -1) {
                int wordLen = i - wordStart;
                for (int j = 0; j < wordLen; j++) {
                    words[wordCount][j] = tolower(paragraph[wordStart + j]);
                }
                words[wordCount][wordLen] = '\0';
                wordCount++;
                wordStart = -1;
            }
        }
    }
    
    // Count frequencies of all words
    for (int i = 0; i < wordCount; i++) {
        frequencies[i] = 0;
        for (int j = 0; j < wordCount; j++) {
            if (strcmp(words[i], words[j]) == 0) {
                frequencies[i]++;
            }
        }
    }
    
    // Find maximum frequency among non-banned words
    int maxCount = 0;
    for (int i = 0; i < wordCount; i++) {
        // Check if banned
        int isBanned = 0;
        for (int j = 0; j < bannedSize; j++) {
            if (strcmp(words[i], banned[j]) == 0) {
                isBanned = 1;
                break;
            }
        }
        if (!isBanned && frequencies[i] > maxCount) {
            maxCount = frequencies[i];
        }
    }
    
    // Process words left to right and track when each word first reaches max count
    char* result = malloc(MAX_WORD_LEN);
    result[0] = '\0';
    
    int currentCounts[MAX_WORDS];
    for (int i = 0; i < MAX_WORDS; i++) {
        currentCounts[i] = 0;
    }
    
    char uniqueWords[MAX_WORDS][MAX_WORD_LEN];
    int uniqueCount = 0;
    
    for (int i = 0; i < wordCount; i++) {
        // Check if banned
        int isBanned = 0;
        for (int j = 0; j < bannedSize; j++) {
            if (strcmp(words[i], banned[j]) == 0) {
                isBanned = 1;
                break;
            }
        }
        if (isBanned) continue;
        
        // Find or add word to unique list
        int wordIndex = -1;
        for (int j = 0; j < uniqueCount; j++) {
            if (strcmp(words[i], uniqueWords[j]) == 0) {
                wordIndex = j;
                break;
            }
        }
        if (wordIndex == -1) {
            strcpy(uniqueWords[uniqueCount], words[i]);
            wordIndex = uniqueCount;
            uniqueCount++;
        }
        
        currentCounts[wordIndex]++;
        if (currentCounts[wordIndex] == maxCount && result[0] == '\0') {
            strcpy(result, words[i]);
            break;
        }
    }
    
    return result;
}

int main() {
    char paragraph[MAX_TEXT_LEN];
    fgets(paragraph, sizeof(paragraph), stdin);
    paragraph[strcspn(paragraph, "\n")] = 0;
    
    char bannedLine[MAX_TEXT_LEN];
    fgets(bannedLine, sizeof(bannedLine), stdin);
    bannedLine[strcspn(bannedLine, "\n")] = 0;
    
    // Parse banned array
    char banned[100][MAX_WORD_LEN];
    int bannedSize = 0;
    
    if (strlen(bannedLine) > 2) {
        const char* p = bannedLine;
        while (*p && *p != '[') p++;
        if (*p == '[') p++;
        
        while (*p && *p != ']') {
            while (*p == ' ' || *p == ',') p++;
            if (*p == ']' || *p == '\0') break;
            
            if (*p == '"') p++;
            int len = 0;
            while (*p && *p != '"' && *p != ',' && *p != ']') {
                banned[bannedSize][len++] = *p;
                p++;
            }
            banned[bannedSize][len] = '\0';
            if (*p == '"') p++;
            
            if (len > 0) {
                bannedSize++;
            }
        }
    }
    
    char* result = solution(paragraph, banned, bannedSize);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

For each of m unique words, we scan the entire text of length n to count occurrences

✓ Linear Growth

Space Complexity

O(n)

Store all extracted words and banned words set

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~15 min Avg. Time

856 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 - Manual Word Processing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler