1075EasyArrayHash TableStringCounting

The Commonest Allowed Word

Tracked in this browser only

Trains the technique from

This is an original problem, written from a brief that listed the technique, the difficulty, the topics, the function shape and the input bounds — none of that problem's wording, examples, hints or editorials. The link is there so you can map your practice onto the standard set.

Same function shape, different story and different numbers.

A notice is given as the string text, made of English letters in either case, spaces, and the marks '!', '?', "'", ',', ';' and '.'. A list of barred words is given as barred, all in lowercase.

Split the notice into words, where a word is a run of letters and everything else is a separator. Words are compared with case ignored.

Return, in lowercase, the word that appears most often among those not barred. Exactly one word appears most often, and at least one word is not barred.

Examples

Example 1

Input: text = "Cat cat CAT dog!", barred = ["dog"]
Output: "cat"

Case is ignored, so the three spellings of the same word count together as three, while the barred word is left out.

Example 2

Input: text = "a b a", barred = ["b"]
Output: "a"

The middle word is barred, leaving the other appearing twice.

Example 3

Input: text = "Tick tock tick tock tick", barred = []
Output: "tick"

The first word appears three times against the other's two, and since case is ignored the capitalised spelling counts with the rest.

Constraints

1 <= text.length <= 1000
0 <= barred.length <= 100
1 <= barred[i].length <= 10
Every barred word is made of lowercase English letters.

The signature

The editor is preloaded with this. It matches the parent problem's shape, so a solution that works here transfers to a judge unchanged.

Python

def most_common_word(text: str, barred: list[str]) -> str:

Java

public String mostCommonWord(String text, String[] barred)

The intended approach

Time O(n + b) for a notice of length n and b barred words.Space O(n) for the words and the tallies.

Fold the notice down to a list of lowercase words in one pass: gather letters while they keep coming and close off a word at anything else, remembering to close off whatever is still gathering when the notice ends. Put the barred words into a lookup so testing one is constant. Then tally the words that are not barred, and take whichever tally is largest. Since exactly one word appears most often, nothing has to be decided between equals, and one pass over the tallies finds it.

Pythonentry point: most_common_word

def most_common_word(text, barred):
    lowers = "abcdefghijklmnopqrstuvwxyz"
    uppers = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    stop = set(barred)
    tally = {}
    word = []
    def close():
        if not word:
            return
        made = "".join(word)
        del word[:]
        if made in stop:
            return
        tally[made] = tally.get(made, 0) + 1
    for ch in text:
        if ch in lowers:
            word.append(ch)
        elif ch in uppers:
            word.append(lowers[uppers.index(ch)])
        else:
            close()
    close()
    best = None
    count = -1
    for made in tally:
        if tally[made] > count:
            count = tally[made]
            best = made
    return best if best is not None else ""

The obvious version

Split the notice by replacing every separator with a space and then breaking on spaces, folding each piece to lowercase. Then for each distinct piece that is not barred, scan the whole list of pieces counting how often it appears, and keep the piece with the largest count. Costs the words squared rather than one tally pass.

This is not filler. It was written independently of the fast solution and the two were run against thousands of random inputs to confirm they agree — which is how the answer above is known to be right. Read it when the intended approach feels like a rabbit pulled out of a hat.

Python

def bf_most_common_word(text, barred):
    marks = "!?',;."
    flat = []
    for ch in text:
        if ch in marks:
            flat.append(' ')
        else:
            flat.append(ch)
    pieces = []
    for piece in "".join(flat).split(' '):
        if piece:
            pieces.append(piece.lower())
    best = None
    count = -1
    for piece in pieces:
        if piece in barred:
            continue
        here = 0
        for other in pieces:
            if other == piece:
                here += 1
        if here > count:
            count = here
            best = piece
    return best if best is not None else ""

How this problem was checked

Reference solution executed against 17 test cases — 17 passed
3 worked examples confirmed by running the code
0 eight-word sequences shared with the parent problem's text
Agrees with an independent brute-force implementation on random inputs
Test set proven to catch deliberately broken solutions
Reviewed by a separate quality pass
Function arity matches the parent problem's

Create a free account to unlock the solution

See the step-by-step animation, the intuition, and clean code in every language — free, no credit card.

Create a free account Already have an account? Sign in