Skip to content

1832. Check if the Sentence Is Pangram

Description

A pangram is a sentence where every letter of the English alphabet appears at least once.

Given a string sentence containing only lowercase English letters, return true if sentence is a pangram, or false otherwise.

 

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.

Solutions

Solution 1: Array or Hash Table

Thinking

We must test whether every lowercase letter appears. A linear scan is enough; only the presence set matters.

Insert characters into a set and check whether its size is \(26\).

Traverse the string sentence, use an array or hash table to record the letters that have appeared, and finally check whether there are \(26\) letters in the array or hash table.

The time complexity is \(O(n)\), and the space complexity is \(O(C)\). Where \(n\) is the length of the string sentence, and \(C\) is the size of the character set. In this problem, \(C = 26\).

1
2
3
class Solution:
    def checkIfPangram(self, sentence: str) -> bool:
        return len(set(sentence)) == 26

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
class Solution {
    public boolean checkIfPangram(String sentence) {
        boolean[] vis = new boolean[26];
        for (int i = 0; i < sentence.length(); ++i) {
            vis[sentence.charAt(i) - 'a'] = true;
        }
        for (boolean v : vis) {
            if (!v) {
                return false;
            }
        }
        return true;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
class Solution {
public:
    bool checkIfPangram(string sentence) {
        int vis[26] = {0};
        for (char& c : sentence) vis[c - 'a'] = 1;
        for (int& v : vis)
            if (!v) return false;
        return true;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
func checkIfPangram(sentence string) bool {
    vis := [26]bool{}
    for _, c := range sentence {
        vis[c-'a'] = true
    }
    for _, v := range vis {
        if !v {
            return false
        }
    }
    return true
}

1
2
3
4
5
6
7
function checkIfPangram(sentence: string): boolean {
    const vis = new Array(26).fill(false);
    for (const c of sentence) {
        vis[c.charCodeAt(0) - 'a'.charCodeAt(0)] = true;
    }
    return vis.every(v => v);
}

1
2
3
4
5
6
7
8
9
impl Solution {
    pub fn check_if_pangram(sentence: String) -> bool {
        let mut vis = [false; 26];
        for c in sentence.as_bytes() {
            vis[(*c - b'a') as usize] = true;
        }
        vis.iter().all(|v| *v)
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
bool checkIfPangram(char* sentence) {
    int vis[26] = {0};
    for (int i = 0; sentence[i]; i++) {
        vis[sentence[i] - 'a'] = 1;
    }
    for (int i = 0; i < 26; i++) {
        if (!vis[i]) {
            return 0;
        }
    }
    return 1;
}

Solution 2: Bit Manipulation

Thinking

Solution 1 stores a hash set. With only \(26\) letters, bit \(i\) of an integer \(mask\) can mark letter \(i\). The sentence is a pangram iff \(mask=2^{26}-1\), using constant extra space.

We can also use an integer \(mask\) to record the letters that have appeared, where the \(i\)-th bit of \(mask\) indicates whether the \(i\)-th letter has appeared.

Finally, check whether there are \(26\) \(1\)s in the binary representation of \(mask\), that is, check whether \(mask\) is equal to \(2^{26} - 1\). If so, return true, otherwise return false.

The time complexity is \(O(n)\), where \(n\) is the length of the string sentence. The space complexity is \(O(1)\).

1
2
3
4
5
6
class Solution:
    def checkIfPangram(self, sentence: str) -> bool:
        mask = 0
        for c in sentence:
            mask |= 1 << (ord(c) - ord('a'))
        return mask == (1 << 26) - 1

1
2
3
4
5
6
7
8
9
class Solution {
    public boolean checkIfPangram(String sentence) {
        int mask = 0;
        for (int i = 0; i < sentence.length(); ++i) {
            mask |= 1 << (sentence.charAt(i) - 'a');
        }
        return mask == (1 << 26) - 1;
    }
}

1
2
3
4
5
6
7
8
class Solution {
public:
    bool checkIfPangram(string sentence) {
        int mask = 0;
        for (char& c : sentence) mask |= 1 << (c - 'a');
        return mask == (1 << 26) - 1;
    }
};

1
2
3
4
5
6
7
func checkIfPangram(sentence string) bool {
    mask := 0
    for _, c := range sentence {
        mask |= 1 << int(c-'a')
    }
    return mask == 1<<26-1
}

1
2
3
4
5
6
7
function checkIfPangram(sentence: string): boolean {
    let mark = 0;
    for (const c of sentence) {
        mark |= 1 << (c.charCodeAt(0) - 'a'.charCodeAt(0));
    }
    return mark === (1 << 26) - 1;
}

1
2
3
4
5
6
7
8
9
impl Solution {
    pub fn check_if_pangram(sentence: String) -> bool {
        let mut mark = 0;
        for c in sentence.as_bytes() {
            mark |= 1 << (*c - b'a');
        }
        mark == (1 << 26) - 1
    }
}

1
2
3
4
5
6
7
bool checkIfPangram(char* sentence) {
    int mark = 0;
    for (int i = 0; sentence[i]; i++) {
        mark |= 1 << (sentence[i] - 'a');
    }
    return mark == (1 << 26) - 1;
}

Comments