0998EasyHash TableString

Does the Notice Use Every Letter

Tracked in this browser only

Trains the technique from

LeetCode 1832Check if the Sentence Is Pangram

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 notice, written in lowercase English letters and nothing else.

Return whether the notice uses every one of the twenty-six letters at least once.

Examples

Example 1

Input: notice = "packmyboxwithfivedozenliquorjugs"
Output: true

Every letter of the alphabet turns up somewhere in the notice, several of them more than once, which is allowed.

Example 2

Input: notice = "abcdefghijklmnopqrstuvwxy"
Output: false

The notice runs from the first letter to the twenty-fifth and stops, so the last letter never appears.

Example 3

Input: notice = "hello"
Output: false

Far too short to hold all twenty-six letters, and it uses only four different ones.

Constraints

1 <= notice.length <= 1000
notice consists of lowercase English letters only.

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 check_if_pangram(notice: str) -> bool:

Java

public boolean checkIfPangram(String notice)

The intended approach

Time O(n) over the notice's length.Space O(1).

Keep one mark per letter, held as the bits of a single whole number: reading a letter sets the bit standing at its distance from the first letter of the alphabet. Setting a bit that was already set changes nothing, which is exactly the behaviour wanted, since repeats do not matter. At the end the notice uses every letter precisely when all twenty-six marks are set, and that is one comparison against the number whose lowest twenty-six bits are on. No sorting, no counting per letter, and the marks take the same room whatever the notice's length.

Pythonentry point: check_if_pangram

def check_if_pangram(notice):
    seen = 0
    for ch in notice:
        seen |= 1 << (ord(ch) - 97)
    return seen == (1 << 26) - 1

The obvious version

Take the twenty-six letters one at a time and scan the whole notice looking for each, giving up at the first letter that never turns up. Costs a scan of the notice per letter rather than a single pass with marks.

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_check_if_pangram(notice):
    for code in range(26):
        letter = chr(97 + code)
        found = False
        for ch in notice:
            if ch == letter:
                found = True
                break
        if not found:
            return False
    return True

How this problem was checked

Reference solution executed against 15 test cases — 15 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