Check if the Sentence Is Pangram - Practice Coding Problems

Check if the Sentence Is Pangram - Problem

A pangram is a fascinating type of sentence that contains every letter of the English alphabet at least once. The most famous example is "The quick brown fox jumps over the lazy dog."

Your task is to determine whether a given string is a pangram. You'll receive a sentence containing only lowercase English letters, and you need to return true if the sentence is a pangram, or false otherwise.

Think of it as checking if you have a complete collection - you need all 26 letters from 'a' to 'z' to appear at least once in your sentence!

Examples:

"thequickbrownfoxjumpsoverthelazydog" → true (contains all 26 letters)
"leetcode" → false (missing many letters)

Input & Output

example_1.py — Complete Pangram

$ Input: sentence = "thequickbrownfoxjumpsoverthelazydog"

› Output: true

💡 Note: This sentence contains every letter from 'a' to 'z' at least once, making it a perfect pangram.

example_2.py — Incomplete Sentence

$ Input: sentence = "leetcode"

› Output: false

💡 Note: This sentence only contains letters: e, l, t, c, o, d. It's missing 20 letters of the alphabet (a, b, f, g, h, i, j, k, m, n, p, q, r, s, u, v, w, x, y, z).

example_3.py — Edge Case Single Letters

$ Input: sentence = "abcdefghijklmnopqrstuvwxyz"

› Output: true

💡 Note: This string contains exactly one occurrence of each letter in alphabetical order, making it a minimal pangram.

Constraints

1 ≤ sentence.length ≤ 1000
sentence consists of lowercase English letters only
No spaces, punctuation, or uppercase letters to worry about

Visualization

Tap to expand

Understanding the Visualization

Start Collection

Begin with empty collection, scan each character

Collect Letters

Add each new letter type to our collection

Check Completeness

Success when we have all 26 letter types

Key Takeaway

🎯 Key Insight: A pangram detection is essentially a set collection problem - we need to efficiently track which unique letters we've seen and check if we have all 26. The hash set approach with early termination gives us optimal performance!

Asked in

G Google 12 a Amazon 8 🍎 Apple 6 ⊞ Microsoft 5

The optimal solution uses a hash set to track unique letters while scanning the sentence in a single pass. As soon as we encounter all 26 unique letters, we can return true. This approach achieves O(n) time complexity with early termination and uses only O(1) space since the set can hold at most 26 letters.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Set (Optimal)	O(n)	O(1)	Track seen letters in a set while scanning the sentence once
Brute Force (Check Each Letter)	O(26*n) = O(n)	O(1)	For each of the 26 letters, scan the entire sentence to see if it exists
Two-Pass Approach	O(n)	O(1)	First pass builds frequency map, second pass checks completeness

One-Pass Hash Set (Optimal) — Algorithm Steps

Initialize an empty set to store seen letters
Iterate through each character in the sentence once
Add each character to the set of seen letters
Check if set size equals 26 (can do early termination)
Return true if all 26 letters found, false otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create empty set for tracking seen letters

Scan Once

Process each character and add to set

Check Size

Return true when set contains 26 letters

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdbool.h>

bool checkIfPangram(char* sentence) {
    bool seenLetters[26] = {false};
    int uniqueCount = 0;
    int len = strlen(sentence);
    
    for (int i = 0; i < len; i++) {
        int index = sentence[i] - 'a';
        if (!seenLetters[index]) {
            seenLetters[index] = true;
            uniqueCount++;
            // Early termination
            if (uniqueCount == 26) {
                return true;
            }
        }
    }
    
    return uniqueCount == 26;
}

int main() {
    char sentence[1001];
    fgets(sentence, sizeof(sentence), stdin);
    // Remove newline and quotes
    sentence[strcspn(sentence, "\n")] = 0;
    if (sentence[0] == '"') {
        memmove(sentence, sentence+1, strlen(sentence));
        sentence[strlen(sentence)-1] = 0;
    }
    printf("%s\n", checkIfPangram(sentence) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the sentence, set operations are O(1) average

✓ Linear Growth

Space Complexity

O(1)

Hash set stores at most 26 letters, which is constant space

✓ Linear Space

89.3K Views

Medium Frequency

~15 min Avg. Time

1.8K 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

One-Pass Hash Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler