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,
- Convert complete sentence in lower case using lower() method of string data type in python.
- Now pass this sentence into Set(str) so that we could have list of all unique characters present in given string.
- 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).