Skip to content
Related Articles

Related Articles

Improve Article

Check if a String contains Anagrams of length K which does not contain the character X

  • Difficulty Level : Expert
  • Last Updated : 01 Sep, 2021
Geek Week

Given a string S, the task is to check if S contains a pair of substrings of length K which are anagrams of each other and doesn’t contain the character X in them. If no such substring exists, print -1.

Examples: 

Input: S = “geeksforgeeks”, X = ‘f’, K = 5 
Output: geeks geeks 
Explanation: 
Substrings “geeks” and “geeks” are anagrams of each other and does not contain ‘f’.

Input: S = “rotator”, X = ‘a’, K = 3 
Output: rot tor 
Explanation: 
Substrings “rot” and “tor” are anagrams of each other and does not contain ‘a’. 

Approach: 
The idea is to generate prefix sum on the basis of characters. Follow the steps below to solve the problem:  



  • Iterate over the string and generate frequencies of substrings by using the prefix sum array.
  • If a substring with same frequency of characters is already present in the HashMap.
  • Otherwise, store the frequency of characters of the substring with the current substring in the HashMap, if the frequency of the character X in the substring is 0.

Below is the implementation of the above approach:  

Java




// Java Program to implement
// the above approach
import java.util.*;
 
// Class to represent a Substring
// in terms of frequency of
// characters present in it
class Substring {
    int MOD = 1000000007;
 
    // Store count of characters
    int count[];
    Substring() { count = new int[26]; }
 
    public int hashCode()
    {
        int hash = 0;
        for (int i = 0; i < 26; i++) {
            hash += (i + 1) * count[i];
            hash %= MOD;
        }
        return hash;
    }
 
    public boolean equals(Object o)
    {
        if (o == this)
            return true;
        if (!(o instanceof Substring))
            return false;
        Substring ob = (Substring)o;
        for (int i = 0; i < 26; i++) {
            if (ob.count[i] != count[i])
                return false;
        }
        return true;
    }
}
class GFG {
 
    // Function to check anagrams
    static void checkForAnagrams(String s, int n,
                                 char X, int k)
    {
        boolean found = false;
 
        // Prefix array to store frequencies
        // of characters
        int prefix[][] = new int[n + 1][26];
        for (int i = 0; i < n; i++) {
            prefix[i][s.charAt(i) - 97]++;
        }
 
        // Generate prefix sum
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < 26; j++)
                prefix[i][j] += prefix[i - 1][j];
        }
 
        // Map to store frequencies
        HashMap<Substring, Integer> map
            = new HashMap<>();
 
        // Check for anagrams
        for (int i = 0; i < n; i++) {
            if (i + k > n)
                break;
 
            // Generate frequencies of characters
            // of substring starting from i
            Substring sub = new Substring();
            for (int j = 0; j < 26; j++) {
                sub.count[j]
                    = prefix[i + k - 1][j]
                      - (i - 1 >= 0
                             ? prefix[i - 1][j]
                             : 0);
            }
 
            // Check if forbidden character is
            // present, then continue
            if (sub.count[X - 97] != 0)
                continue;
 
            // If already present in HashMap
            if (map.containsKey(sub)) {
 
                found = true;
 
                // Print the substrings
                System.out.println(
                    s.substring(map.get(sub),
                                map.get(sub) + k)
                    + " " + s.substring(i, i + k));
                break;
            }
            else {
                map.put(sub, i);
            }
        }
 
        // If no such substring is found
        if (!found)
            System.out.println("-1");
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        String s = "rotator";
        int n = s.length();
        char X = 'a';
        int k = 3;
        checkForAnagrams(s, n, X, k);
    }
}
Output: 
rot tor

 

Time Complexity: O(N*26) 
Auxiliary Space: O(N*26)
 




My Personal Notes arrow_drop_up
Recommended Articles
Page :