Most Common Word - Practice Coding Problems

Most Common Word - Problem

You're building a word frequency analyzer for text processing! Given a paragraph of text and a list of banned words, your task is to find the most frequently occurring word that isn't on the banned list.

The challenge involves:

Cleaning the text by removing punctuation and converting to lowercase
Counting word frequencies while ignoring banned words
Returning the word with the highest count

For example, in the paragraph "Bob hit a ball, the hit BALL flew far after it was hit." with banned words ["hit"], the word "ball" appears twice and is the most frequent non-banned word.

Note: It's guaranteed that there's at least one non-banned word, and the answer is unique.

Input & Output

example_1.py — Basic Case

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

› Output: "ball"

💡 Note: After removing punctuation and converting to lowercase, we have words: ["bob", "hit", "a", "ball", "the", "hit", "ball", "flew", "far", "after", "it", "was", "hit"]. Excluding "hit" (banned), "ball" appears 2 times, which is the maximum frequency.

example_2.py — Multiple Banned Words

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

› Output: "b"

💡 Note: After cleaning: ["a", "a", "a", "a", "b", "b", "b", "c", "c"]. Excluding "a" (banned), "b" appears 3 times and "c" appears 2 times. So "b" is the most frequent.

example_3.py — Case Insensitive

$ Input: paragraph = "Bob. hIt, baLl", banned = ["bob", "hit"]

› Output: "ball"

💡 Note: After converting to lowercase and removing punctuation: ["bob", "hit", "ball"]. Both "bob" and "hit" are banned, leaving only "ball" as the valid answer.

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
There is at least one word in paragraph that is not banned
The answer is unique

Visualization

Tap to expand

Understanding the Visualization

Clean the Data

Remove punctuation and convert to lowercase, like standardizing ballot formats

Count Valid Votes

Use hash table to count each valid (non-banned) word, like tallying votes in real-time

Track the Leader

Keep track of the word with highest count as we process, like updating election results live

Declare Winner

Return the most frequent valid word, like announcing the election winner

Key Takeaway

🎯 Key Insight: Use a hash table to count frequencies in a single pass - this transforms an O(n²) nested loop problem into an optimal O(n) solution by leveraging O(1) average-case hash table operations.

Asked in

a Amazon 45 G Google 32 f Meta 28 ⊞ Microsoft 22

The optimal solution uses a hash table to count word frequencies in a single pass. Clean the paragraph by removing punctuation and converting to lowercase, then iterate through each word once. For each non-banned word, increment its count in the hash table and track the current maximum. This achieves O(n) time complexity with O(n) space for the hash table.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(n)	For each word, scan the entire text to count its occurrences
One-Pass Hash Table (Optimal)	O(n)	O(n)	Count word frequencies in a single pass using hash table

Brute Force (Nested Loops) — Algorithm Steps

Clean the paragraph by removing punctuation and converting to lowercase
Split the text into individual words
For each unique word, count its total occurrences in the text
Skip banned words during counting
Return the word with maximum count

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Words

Clean text and split into individual words

Count Each Word

For each word, scan entire list to count occurrences

Track Maximum

Keep track of word with highest count so far

Code -

solution.c — C

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

char* mostCommonWord(char* paragraph, char** banned, int bannedSize, int* returnSize) {
    int len = strlen(paragraph);
    char* words[1000];
    int wordCount = 0;
    
    // Convert to lowercase and extract words
    char* temp = (char*)malloc((len + 1) * sizeof(char));
    strcpy(temp, paragraph);
    
    for (int i = 0; i < len; i++) {
        temp[i] = tolower(temp[i]);
        if (!isalpha(temp[i])) temp[i] = ' ';
    }
    
    char* token = strtok(temp, " ");
    while (token != NULL && wordCount < 1000) {
        words[wordCount] = (char*)malloc(strlen(token) + 1);
        strcpy(words[wordCount], token);
        wordCount++;
        token = strtok(NULL, " ");
    }
    
    int maxCount = 0;
    char* result = (char*)malloc(50 * sizeof(char));
    
    for (int i = 0; i < wordCount; i++) {
        int isBanned = 0;
        for (int j = 0; j < bannedSize; j++) {
            if (strcmp(words[i], banned[j]) == 0) {
                isBanned = 1;
                break;
            }
        }
        
        if (!isBanned) {
            int count = 0;
            for (int j = 0; j < wordCount; j++) {
                if (strcmp(words[i], words[j]) == 0) count++;
            }
            
            if (count > maxCount) {
                maxCount = count;
                strcpy(result, words[i]);
            }
        }
    }
    
    free(temp);
    for (int i = 0; i < wordCount; i++) {
        free(words[i]);
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the n words, we scan through all n words again to count occurrences

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing the cleaned words list and banned words set

⚡ Linearithmic Space

98.0K Views

Medium Frequency

~15 min Avg. Time

2.1K 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler