Pangram Checker - Problem

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

Given a string sentence, write a function to determine if it is a pangram. The check should be case-insensitive, meaning both uppercase and lowercase letters count.

Note: Only English alphabet letters (a-z) need to be considered. Numbers, spaces, and special characters can be ignored.

Input & Output

Example 1 — Classic Pangram

$ Input: sentence = "The quick brown fox jumps over the lazy dog"

› Output: true

💡 Note: This famous sentence contains all 26 letters: t,h,e,q,u,i,c,k,b,r,o,w,n,f,x,j,m,p,s,v,l,a,z,y,d,g

Example 2 — Missing Letters

$ Input: sentence = "Hello world"

› Output: false

💡 Note: Contains only 7 unique letters: h,e,l,o,w,r,d. Missing 19 letters including a,b,c,f,g,i,j,k,m,n,p,q,s,t,u,v,x,y,z

Example 3 — Mixed Case

$ Input: sentence = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

› Output: true

💡 Note: All 26 uppercase letters present. Case-insensitive check passes since all alphabet letters are covered

Constraints

1 ≤ sentence.length ≤ 1000
sentence consists of lowercase and uppercase English letters, digits, and spaces

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to track which alphabet letters we've encountered as we scan the sentence. The best approach uses a boolean array with early termination - as soon as we find all 26 letters, we can return true immediately. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Check Each Letter Individually

⏱️ Time: O(26 × n) = O(n) Space: O(1)

Loop through all 26 letters (a-z) and for each letter, scan the entire sentence to check if that letter appears at least once. Convert everything to lowercase for case-insensitive comparison.

Early Termination with Boolean Array

⏱️ Time: O(n) Space: O(1)

Use a boolean array of size 26 to mark which letters we've seen. Keep a counter of unique letters found. As soon as the counter reaches 26, we can return true immediately without processing the rest of the sentence.

Set-Based Tracking

⏱️ Time: O(n) Space: O(1)

Iterate through the sentence once, adding each alphabetic character to a set. A set automatically handles duplicates. Check if the final set contains all 26 letters of the alphabet.

Brute Force - Check Each Letter Individually — Algorithm Steps

Iterate through each letter from 'a' to 'z'
For each letter, scan the entire sentence to find at least one occurrence
If any letter is missing, return false
If all 26 letters are found, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Check 'a'

Scan entire sentence for letter 'a'

Check 'b'

Scan entire sentence for letter 'b'

Continue

Repeat for all 26 letters

Code -

solution.c — C

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

bool solution(char* sentence) {
    int len = strlen(sentence);
    for (char letter = 'a'; letter <= 'z'; letter++) {
        bool found = false;
        for (int i = 0; i < len; i++) {
            if (tolower(sentence[i]) == letter) {
                found = true;
                break;
            }
        }
        if (!found) {
            return false;
        }
    }
    return true;
}

int main() {
    char sentence[1000];
    fgets(sentence, sizeof(sentence), stdin);
    sentence[strcspn(sentence, "\n")] = 0;
    bool result = solution(sentence);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(26 × n) = O(n)

For each of 26 letters, we scan the sentence of length n

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

892 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

Pangram Checker - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check Each Letter Individually — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler