The problem “Check if the Sentence Is Pangram” on Leetcode is a captivating exercise that combines language processing and basic data structures. The problem gives programmers an opportunity to demonstrate their skills in Python, especially in the manipulation of strings and sets. This article will provide a comprehensive understanding of various approaches to solve this problem, while highlighting best practices and potential pitfalls.
A pangram is a sentence where every letter of the English alphabet appears at least once. Given a string
True if the sentence is a pangram or
- 1 ≤ ∣sentence∣ ≤1000
sentenceconsists of lowercase and uppercase English letters.
sentence = "The quick brown fox jumps over the lazy dog"
Approach 1: Brute-Force
The simplest approach involves creating a list of all the alphabets and then iterating over the sentence to remove the encountered letters from the list.
def checkIfPangram(sentence): alphabets = list("abcdefghijklmnopqrstuvwxyz") for char in sentence: if char.lower() in alphabets: alphabets.remove(char.lower()) return len(alphabets) == 0
The time complexity is O(n×m), where n is the length of the sentence and m is the number of alphabets remaining to be found. In the worst-case, this can go up to 26.
The space complexity is O(1) since the list of alphabets is of constant size.
Approach 2: Using Sets
A more Pythonic approach involves utilizing the set data structure. Convert the sentence into a set of its constituent letters and compare it with the set of all alphabets.
def checkIfPangram(sentence): alphabets = set("abcdefghijklmnopqrstuvwxyz") sentence_set = set(sentence.lower()) return alphabets.issubset(sentence_set)
The time complexity is O(n), where n is the length of the sentence.
The space complexity is O(1) as the set sizes are constant.
Approach 3: Counting Uniques
This approach is about counting the unique alphabets present in the sentence and comparing that count with 26.
def checkIfPangram(sentence): return len(set(sentence.lower())) >= 26
The time complexity is O(n), which is the same as the set-based approach.
The space complexity is O(1).
It’s advisable to validate the chosen approach with different test cases.
def test_checkPangram(): assert checkIfPangram("The quick brown fox jumps over the lazy dog") == True assert checkIfPangram("Hello, World!") == False assert checkIfPangram("Python is amazing") == False print("All test cases pass") test_checkPangram()
The “Check if the Sentence Is Pangram” problem is a straightforward but educational problem that teaches important concepts in Python programming. It is versatile in that it can be approached in various ways, each with its pros and cons, teaching us valuable lessons in time and space complexity. Choosing the correct data structure and being aware of Python’s built-in capabilities can make the code more elegant and efficient.