Related Articles
Check if a String contains Anagrams of length K which does not contain the character X
• Difficulty Level : Expert
• Last Updated : 25 Aug, 2020

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’.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 genertae 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 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 :