Check if the Sentence Is Pangram

Problem Statement

A pangram is a special type of sentence in the English language that contains every letter from 'a' to 'z' at least once. The challenge is to determine whether a given string, which consists only of lowercase English letters, qualifies as a pangram or not. This determination is binary, resulting in a true response if the string is a pangram and false if it is not. Understanding this, the task involves processing the string in such a way to efficiently check the presence of each alphabet letter.

Examples

Example 1

Input:

sentence = "thequickbrownfoxjumpsoverthelazydog"

Output:

true

Explanation:

sentence contains at least one of every letter of the English alphabet.

Example 2

Input:

sentence = "leetcode"

Output:

false

Constraints

• 1 <= sentence.length <= 1000
• sentence consists of lowercase English letters.

Approach and Intuition

Given the problem and the constraints, a direct approach can be used to solve this efficiently:

1. Understand Requirements: The string should contain all the letters from 'a' to 'z'. We need a way to verify the presence of each of these letters at least once.

2. Initialize Tracking: Use a data structure to keep track of which characters have been seen.

   • A simple array of size 26 can be utilized (since there are 26 letters in the English alphabet). Each position in the array corresponds to a letter (e.g., 0 for 'a', 1 for 'b', etc.).

3. Iterate Over the String: Loop through each character of the string.

   • Convert the character to an index (using ASCII values, where index = character - 'a').
   • Mark the corresponding index in the array as seen (e.g., changing the value at that index to true).

4. Validation Check: After processing all characters, ensure all array indices are marked true.

   • If any index is still false, it means the corresponding letter was not in the string, and thus the input is not a pangram.

This solution is straightforward given the constraint that the string length is at most 1000, making our approach feasible in terms of both time and space complexity. Factors like memory usage are minimized by using a fixed-size array, and the time complexity remains linear with respect to the length of the input string. This compares favorably with methods that might involve sorting or additional hashing, especially considering the limited length and character set of the input strings.

Solutions

class Solution {
public:
    bool isPangram(string inputSentence) {
        array<bool, 26> alphabetCheck{};
            
        for (char character : inputSentence)
            alphabetCheck[character - 'a'] = true;
    
        for (bool indicator : alphabetCheck)
            if (!indicator)
                return false;
    
        return true;
    }
};