 Open in App
Not now

# Check if a string consists of two K-length non-overlapping substrings as anagrams

• Last Updated : 18 Jun, 2021

Given a string str of length N and an integer K, the task is to check if a string has two non-overlapping substrings of length K as anagrams.

Examples:

Input: str = “ginfing”, K = 3
Output: Yes
Explanation:
“gin” and “ing” are the two non overlapping substrings of length 3 which are anagrams.
Therefore, the output is Yes.

Input: str = “ginig”, K = 3
Output: No
Explanation:
In the given string, there are no two non overlapping substrings of length 3 which are anagrams. Note that substring “gin” and substring “nig” are anagrams, but they are overlapping, hence are not considered.
Hence, the output is No.

Approach: The idea to solve this problem is to traverse the given string and use a set to store the substrings of length K and search for two non-overlapping substrings present in the given string. Follow the steps below:

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `#include ` `using` `namespace` `std;`   `// Function to check whether the string` `// s has two non-overlapping substrings` `// of length K as anagrams` `void` `anagramPairs(string str, ``int` `K)` `{` `    ``// Stores the substrings of length K` `    ``unordered_set set;` `    ``int` `l = str.length();`   `    ``// Iterate through every character` `    ``for` `(``int` `i = 0; i < l; i++) {`   `        ``// If there is a substring starting` `        ``// at index i - 1 of length K then` `        ``// erase that substring from set` `        ``if` `(i > 0 && K - (i - 1) - 1 < l) {` `            ``string s1 = str.substr(i - 1, K);`   `            ``// Sort the substring` `            ``sort(s1.begin(), s1.end());`   `            ``// Remove from set` `            ``set.erase(s1);` `        ``}`   `        ``// If there is a substring of length` `        ``// K ending at index i - 1` `        ``if` `((i - 1) - K + 1 >= 0) {`   `            ``string s1 = str.substr(` `                ``(i - 1) - K + 1, K);`   `            ``// Sort the substring` `            ``sort(s1.begin(), s1.end());`   `            ``// Insert substring into the Set` `            ``set.insert(s1);` `        ``}`   `        ``// If there is a substring of length` `        ``// K starting from the i-th index` `        ``if` `(K + i - 1 < l) {`   `            ``// Check if the sorted` `            ``// substring is present in` `            ``// the set or not` `            ``string s1 = str.substr(i, K);`   `            ``sort(s1.begin(), s1.end());`   `            ``// If present in the Set` `            ``if` `(set.count(s1)) {` `                ``cout << ``"Yes"``;` `                ``return``;` `            ``}`   `            ``// Insert the sorted` `            ``// substring into the set` `            ``set.insert(s1);` `        ``}` `    ``}`   `    ``// If not present in the Set` `    ``cout << ``"No"``;` `}`   `// Driver Code` `int` `main()` `{` `    ``string str = ``"ginfing"``;` `    ``int` `K = 3;`   `    ``// Function Call` `    ``anagramPairs(str, K);` `    ``return` `0;` `}`

## Java

 `// Java program for the above approach`   `import` `java.util.*;`   `class` `GFG` `{`   `// Function to check whether the String` `// s has two non-overlapping subStrings` `// of length K as anagrams` `static` `void` `anagramPairs(String str, ``int` `K)` `{` `  `  `    ``// Stores the subStrings of length K` `    ``HashSet set = ``new` `HashSet();` `    ``int` `l = str.length();`   `    ``// Iterate through every character` `    ``for` `(``int` `i = ``0``; i < l; i++) ` `    ``{`   `        ``// If there is a subString starting` `        ``// at index i - 1 of length K then` `        ``// erase that subString from set` `        ``if` `(i > ``0` `&& K - (i - ``1``) - ``1` `< l)` `        ``{` `            ``String s1 = str.substring(i - ``1``, K);`   `            ``// Sort the subString` `            ``s1 = sortString(s1);`   `            ``// Remove from set` `            ``set.remove(s1);` `        ``}`   `        ``// If there is a subString of length` `        ``// K ending at index i - 1` `        ``if` `((i - ``1``) - K + ``1` `>= ``0``)` `        ``{`   `            ``String s1 = str.substring(` `                ``(i - ``1``) - K + ``1``, K);`   `            ``// Sort the subString` `            ``s1 = sortString(s1);`   `            ``// Insert subString into the Set` `            ``set.add(s1);` `        ``}`   `        ``// If there is a subString of length` `        ``// K starting from the i-th index` `        ``if` `(K + i - ``1` `< l)` `        ``{`   `            ``// Check if the sorted` `            ``// subString is present in` `            ``// the set or not` `            ``String s1 = str.substring(i, i+K);`   `            ``s1 = sortString(s1);`   `            ``// If present in the Set` `            ``if` `(set.contains(s1))` `            ``{` `                ``System.out.print(``"Yes"``);` `                ``return``;` `            ``}`   `            ``// Insert the sorted` `            ``// subString into the set` `            ``set.add(s1);` `        ``}` `    ``}`   `    ``// If not present in the Set` `    ``System.out.print(``"No"``);` `}` `static` `String sortString(String inputString) ` `{ ` `  `  `    ``// convert input string to char array ` `    ``char` `tempArray[] = inputString.toCharArray(); ` `      `  `    ``// sort tempArray ` `    ``Arrays.sort(tempArray); ` `      `  `    ``// return new sorted string ` `    ``return` `new` `String(tempArray); ` `}` `  `  `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``String str = ``"ginfing"``;` `    ``int` `K = ``3``;`   `    ``// Function Call` `    ``anagramPairs(str, K);` `}` `}`   `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 program for the above approach`   `# Function to check whether the string` `# s has two non-overlapping substrings` `# of length K as anagrams` `def` `anagramPairs(``str``, K):` `    `  `    ``# Stores the substrings of length K` `    ``sett ``=` `{}` `    ``l ``=` `len``(``str``)`   `    ``# Iterate through every character` `    ``for` `i ``in` `range``(l):`   `        ``# If there is a substring starting` `        ``# at index i - 1 of length K then` `        ``# erase that substring from sett` `        ``if` `(i > ``0` `and` `K ``-` `(i ``-` `1``) ``-` `1` `< l):` `            ``s1 ``=` `str``[i ``-` `1``:i ``+` `K ``-` `1``]`   `            ``# Sort the substring` `            ``s1 ``=` `sorted``(s1)`   `            ``# Remove from sett` `            ``del` `sett["".join(s1)]`   `        ``# If there is a substring of length` `        ``# K ending at index i - 1` `        ``if` `((i ``-` `1``) ``-` `K ``+` `1` `>``=` `0``):`   `            ``s1 ``=` `str``[(i ``-` `1``) ``-` `K ``+` `1``:i]`   `            ``# Sort the substring` `            ``s1 ``=` `sorted``(s1)`   `            ``# Insert substring into the Set` `            ``sett["".join(s1)] ``=` `1`   `        ``# If there is a substring of length` `        ``# K starting from the i-th index` `        ``if` `(K ``+` `i ``-` `1` `< l):`   `            ``# Check if the sorted` `            ``# substring is present in` `            ``# the sett or not` `            ``s1 ``=` `str``[i : i ``+` `K]`   `            ``s1 ``=` `sorted``(s1)`   `            ``# If present in the Set` `            ``if` `"".join(s1) ``in` `sett:` `                ``print``(``"Yes"``)` `                ``return`   `            ``#Insert the sorted` `            ``# substring into the sett` `            ``sett["".join(s1)] ``=` `1`   `    ``# If not present in the Set` `    ``print``(``"No"``)`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``str` `=` `"ginfing"` `    ``K ``=` `3`   `    ``# Function Call` `    ``anagramPairs(``str``, K)`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG` `{`   `// Function to check whether the String` `// s has two non-overlapping subStrings` `// of length K as anagrams` `static` `void` `anagramPairs(String str, ``int` `K)` `{` `  `  `    ``// Stores the subStrings of length K` `    ``HashSet ``set` `= ``new` `HashSet();` `    ``int` `l = str.Length;`   `    ``// Iterate through every character` `    ``for` `(``int` `i = 0; i < l; i++) ` `    ``{`   `        ``// If there is a subString starting` `        ``// at index i - 1 of length K then` `        ``// erase that subString from set` `        ``if` `(i > 0 && K - (i - 1) - 1 < l)` `        ``{` `            ``String s1 = str.Substring(i - 1, K);`   `            ``// Sort the subString` `            ``s1 = sortString(s1);`   `            ``// Remove from set` `            ``set``.Remove(s1);` `        ``}`   `        ``// If there is a subString of length` `        ``// K ending at index i - 1` `        ``if` `((i - 1) - K + 1 >= 0)` `        ``{`   `            ``String s1 = str.Substring(` `                ``(i - 1) - K + 1, K);`   `            ``// Sort the subString` `            ``s1 = sortString(s1);`   `            ``// Insert subString into the Set` `            ``set``.Add(s1);` `        ``}`   `        ``// If there is a subString of length` `        ``// K starting from the i-th index` `        ``if` `(K + i - 1 < l)` `        ``{`   `            ``// Check if the sorted` `            ``// subString is present in` `            ``// the set or not` `            ``String s1 = str.Substring(i, K);`   `            ``s1 = sortString(s1);`   `            ``// If present in the Set` `            ``if` `(``set``.Contains(s1))` `            ``{` `                ``Console.Write(``"Yes"``);` `                ``return``;` `            ``}`   `            ``// Insert the sorted` `            ``// subString into the set` `            ``set``.Add(s1);` `        ``}` `    ``}`   `    ``// If not present in the Set` `    ``Console.Write(``"No"``);` `}` `static` `String sortString(String inputString) ` `{ ` `  `  `    ``// convert input string to char array ` `    ``char` `[]tempArray = inputString.ToCharArray(); ` `      `  `    ``// sort tempArray ` `    ``Array.Sort(tempArray); ` `      `  `    ``// return new sorted string ` `    ``return` `new` `String(tempArray); ` `}` `  `  `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``String str = ``"ginfing"``;` `    ``int` `K = 3;`   `    ``// Function Call` `    ``anagramPairs(str, K);` `}` `}`   `// This code is contributed by Princi Singh`

## Javascript

 ``

Output:

`Yes`

Time Complexity: O(N*(K + K*log K))
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Related Articles