Open In App
Related Articles

Using Set() in Python Pangram Checking

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Given a string check if it is Pangram or not. A pangram is a sentence containing every letter in the English Alphabet. Lowercase and Uppercase are considered the same. Examples:

Input : str = 'The quick brown fox jumps over 
               the lazy dog'
Output : Yes
// Contains all the characters from ‘a’ to ‘z’

Input : str='The quick brown fox jumps over the dog'
Output : No
// Doesn’t contains all the characters from ‘a’
// to ‘z’, as ‘l’, ‘z’, ‘y’ are missing

This problem has existing solution please refer Pangram Checking link. We will solve this in Python using Set() data structure and List() comprehension. Approach is very simple,

  1. Convert complete sentence in lower case using lower() method of string data type in python.
  2. Now pass this sentence into Set(str) so that we could have list of all unique characters present in given string.
  3. Now separate out list of all alphabets (a-z), if length of list is 26 that means all characters are present and sentence is Pangram otherwise not.

Implementation:

Python3

# function to check pangram
 
def pangram(input):
     
    # convert input string into lower case
    input = input.lower()
     
    # convert input string into Set() so that we will
    # list of all unique characters present in sentence
    input = set(input)
 
    # separate out all alphabets
    # ord(ch) returns ascii value of character
    alpha = [ ch for ch in input if ord(ch) in range(ord('a'), ord('z')+1)]
 
    if len(alpha) == 26:
        return 'true'
    else:
        return 'false'
 
# Driver program
if __name__ == "__main__":
    input = 'The quick brown fox jumps over the lazy dog'
    print (pangram(input))

                    

Java

import java.util.*;
 
public class PangramChecker {
    public static void main(String[] args) {
        // Define the input string
        String input = "The quick brown fox jumps over the lazy dog";
 
        // Call the pangram function and print the result
        System.out.println(pangram(input));
    }
 
    public static String pangram(String input) {
        // Convert the input string to lowercase
        input = input.toLowerCase();
 
        // Create a set to store unique characters in the input string
        Set<Character> inputSet = new HashSet<>();
 
        // Loop through each character in the input string
        for (int i = 0; i < input.length(); i++) {
            char ch = input.charAt(i);
            // Check if the character is an alphabet
            if (ch >= 'a' && ch <= 'z') {
                // Add the character to the input set
                inputSet.add(ch);
            }
        }
 
        // Convert the input set to a list and sort it
        List<Character> alpha = new ArrayList<>(inputSet);
        Collections.sort(alpha);
 
        // Create a StringBuilder to concatenate the sorted characters into a string
        StringBuilder sb = new StringBuilder();
        for (char ch : alpha) {
            sb.append(ch);
        }
        String uniqueChars = sb.toString();
 
        // Check if the length of the resulting string is 26 (i.e., contains all alphabets)
        if (uniqueChars.length() == 26) {
            return "true";
        } else {
            return "false";
        }
    }
}

                    

Output
true

Time complexity: 

  • Lowercasing the input string takes O(n) time, where n is the length of the string.
  • Converting the input string to a set takes O(n) time.
  • The list comprehension that separates out all alphabets takes O(n) time. 
  • The len() function to count the number of alphabets takes O(1) time. 
  • The overall time complexity of the function is therefore O(n).

Auxiliary space:

  • Creating the set to store unique characters in the input string requires O(n) space, where n is the length of the string. 
  • Creating the list of alphabets requires O(k) space, where k is the number of alphabets in the string (which is at most 26). 
  • The overall auxiliary space complexity of the function is therefore O(n).


Last Updated : 14 Mar, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads