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

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

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