Check if given String is Pangram or not in Java

Given string str, our task is to write a Java program that determines if the provided string is a pangram or not. If all of the alphabetic characters are present in a string without considering its case (Uppercase or lowercase), the string is called a pangram string.

Example 1:

Input:

String str = "abCDEfghIJKlmnoPQRStuvwxyZ"

Output:

The given string is a Pangram.

Explanation:

For the given string "abCDEfghIJKlmnoPQRStuvwxyZ", all the 26 alphabets are present without the regard for the case-sensitivity feature. Hence the given string is a Pangram.

Example 2:

Input:

String str = "The five boxing wizards jump quickly."

Output:

The given string is a Pangram.

Explanation:

For the given string, "The five boxing wizards jump quickly," since all 26 alphabets are present without the regard for the case-sensitivity feature. Hence the given string is a Pangram.

Example 3:

Input:

String str = "Hello Welcome to the World"

Output:

The given string is not a Pangram.

Explanation:

For the given string "Hello Welcome to the World", since all the 26 alphabets are not present. Hence the given string is not a Pangram.

Approach: Using Set

The use of a set makes sense since, in order to verify a pangram, all 26 alphabets must be present, irrespective of whether the character is uppercase or lowercase. The alphabets have been placed in lowercase, and the set size needs to be 26 in order to determine whether an alphabet is already present or not.

Algorithm:

Step 1: Initialize a character set.

Step 2: Check the entire string and make certain every character is there.

Step 3: Insert into the set if the character is a lowercase alphabet.

Step 4: Use the tolower() function to change any capital letters to lowercase before inserting them.

Step 5: At the conclusion, verify that the set size is 26. If accurate, this indicates that every alphabet, whether lowercase or uppercase, was used in the string.

Implementation:

FileName: ApproachSetPangram.java

import java.util.*;
import java.io.*;
public class ApproachSetPangram 
{
	static boolean checkPangram(String s) 
	{
		// Create a starting set of characters
		Set<Character> set = new HashSet<>();
		for (char chr : s.toCharArray()) 
		{
			// In the situation that the character 
			// is already lowercase
			if (chr >= 'a' && chr <= 'z')
				set.add(chr);
			// If the character is a uppercase
			if (chr >= 'A' && chr <= 'Z') 
			{
				// converting the characters to lowercase
				chr = Character.toLowerCase(chr);
				set.add(chr);
			}
		}
		// Verify that the size is 26 or not.
		return set.size() == 26;
	}
	public static void main(String[] args) 
	{
		String s = "The five boxing wizards jump quickly";
		if (checkPangram(s))
		{
		    System.out.println("The given string is a Pangram.");
		}
		else
		{
		    System.out.println("The given string is not a Pangram.");   
		}
	}
}

Output

The given string is a Pangram.

Complexity Analysis:

The Time Complexity of the above code is O(N*logN), where 'N' represents the length of the string and the Space Complexity is O(1).

Approach: Using Hashing Technique

Make a mark[] array of Boolean types, iterate over each character in the string, and mark each one as visited. Case and capital letters are regarded as interchangeable. Thus, index 0 is used to indicate "A" and "a," and index 25 is used to mark "Z" and "z." Once every character has been iterated through, determine whether or not every character has been marked. If not, return false because there is no pangram here; otherwise, return true.

Algorithm:

Step 1: Initially, make a bool vector mark[] with a size of 26.

Step 2: Loop over each character in the string s, marking s[i] - "a" or s[i] - "A" as 1 for the upper and lower case, respectively.

Step 3: Go through each of mark's indices once.

Step 3.1: A pangram is returned if every index is marked as visited.

Step 3.2: There is no Pangram in the Else returns.

Implementation:

FileName:

import java.util.*;
import java.io.*;
public class HashingApproachPangram 
{
	public static boolean checkStringPangram(String s)
	{
		// Create a hash table to identify the 
		// characters in the string that are present. 
		// By default, each and every component of
		// mark would not be true.
		boolean[] mark = new boolean[26];
		// utilize mark[] for indexing
		int in = 0;
		// Traverse all characters of the string
		for (int i = 0; i < s.length(); i++) 
		{
			// To find the index, subtract 'A' 
			// if the character is uppercase.
			if ('A' <= s.charAt(i) && s.charAt(i) <= 'Z')
				in = s.charAt(i) - 'A';
			//  To find the index, subtract 'a' 
			// if the character is lowercase.
			else if ('a' <= s.charAt(i) && s.charAt(i) <= 'z')
				in = s.charAt(i) - 'a';
			// Lowercase and uppercase characters if 
			// this character is not an English character.
			else
				continue;
			mark[in] = true;
		}
		// If a character is not marked,
		// return false.
		for (int i = 0; i <= 25; i++)
			if (mark[i] == false)
				return (false);
		// If every character was present
		return (true);
	}
	public static void main(String[] args)
	{
		String s = "The five boxing wizards jump quickly";
		if (checkStringPangram(s) == true)
			System.out.print("The given string is a Pangram.");
		else
			System.out.print("The given string is not a pangram.");
	}
}   

Output

The given string is a Pangram.

Complexity Analysis:

The Time Complexity is O(N), where N represents the length of the given string, and the Space Complexity is O(1).

Approach: Using Frequency Array

Algorithm:

Step 1: Convert all of the string's letters to upper or lower case.

Step 2: To indicate the frequency of each letter from a to z, create a frequency array.

Step 3: Next, iterate through the frequency array and print "No" if any letter is absent from the supplied string and "Yes" otherwise.

Implementation:

FileName: reqarrayApproachPangram.java

import java.io.*;
import java.util.*;
public class FreqarrayApproachPangram 
{
	static int size = 26;
	// Function to determine whether cha is a letter
	static boolean isLetter(char cha)
	{
		if (!Character.isLetter(cha))
			return false;
		return true;
	}
	// Function to determine whether a string 
	// contains every letter in the alphabet, 
	// from a to z
	static boolean CheckLetterString(String s, int length)
	{
		// Change the given string to lowercase
		s = s.toLowerCase();
		// Create a frequency array in order to
		// identify the current letters.
		boolean[] current = new boolean[size];
		// For every character in the string, 
		// traverse through it.
		for (int i = 0; i < length; i++) 
		{
			// If the character that is currently
			// in use as a letter
			if (isLetter(s.charAt(i))) 
			{
				// select the present letter as the current one.
				int curr_letter = s.charAt(i) - 'a';
				current[curr_letter] = true;
			}
		}
		// Go through each letter from a to z.
		for (int i = 0; i < size; i++) 
		{
			// Return false if the character we are 
			// currently using does not exist 
			// in the string; return true otherwise.
			if (!current[i])
				return false;
		}
		return true;
	}
	public static void main(String args[])
	{
		String s = "The five boxing wizards jump quickly";
		int length = s.length();
		if (CheckLetterString(s, length))
			System.out.println("The given string is a Pangram.");
		else
			System.out.println("The given string is not a Pangram.");
	}
}

Output

The given string is a Pangram.

Complexity Analysis:

The Time Complexity is O(N), where N represents the length of the given string, and the Space Complexity is O(1).

Approach: Using Traversal

Algorithm:

Step 1: Declare the LettersPresent flag's initial value to true.

Step 2: Repeat steps a through z for every letter.

Step 2.1: Determine whether the letter is in the string.

Step 3: Break the loop and set the flag to false if any letters are missing.

Step 4: Print "The given string is a Pangram" if every letter is present.

Step 5: Else, print that "The given string is not a Pangram."

Implementation:

FileName: TraversalApproachPangram.java

import java.io.*;
import java.util.*;
public class TraversalApproachPangram 
{
    // Function to determine whether a string
    // contains every letter in the alphabet,
    // from a to z (ignoring case)
	public static void CheckingLetterString(String s)
	{
		// Lowercase representation of the given string
		s = s.toLowerCase();
		boolean LettersPresent = true;
		// Repeat for every character on the list.
		for (char ch = 'a'; ch <= 'z'; ch++) 
		{
			// Verify that the string does not 
			//contains every letter in the string.
			if (!s.contains(String.valueOf(ch))) 
			{
				LettersPresent = false;
				break;
			}
		}
	    // Verify that every letter is present. 
	    // If not, print "Yes," otherwise print "No."
		if (LettersPresent)
			System.out.println("The given string is a Pangram.");
		else
			System.out.println("The given string is not a Pangram.");
	}
	public static void main(String args[])
	{
		String s = "The five boxing wizards jump quickly";
		// Function call
		CheckingLetterString(s);
	}
}

Output