# Number of sub-strings which are anagram of any sub-string of another string

• Difficulty Level : Hard
• Last Updated : 05 Oct, 2021

Given two strings S1 and S2, the task is to count the number of sub-strings of S1 that are anagrams of any sub-string of S2.
Examples:

Input: S1 = “ABB”, S2 = “BAB”
Output:
There are 6 sub-strings of S1 : “A”, “B”, “B”, “AB”, “BB” and “ABB”
Out of which only “BB” is the one which is not an anagram of any sub-string of S2.
Input: S1 = “PLEASEHELPIMTRAPPED”, S2 = “INAKICKSTARTFACTORY”
Output:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Naive approach: A simple approach is to check all the sub-strings of S1 against all the sub-strings of S2 whether they are anagrams or not.
Efficient approach: Take all the sub-strings of S1 one by one say temp and check whether temp is an anagram of any sub-string of S2 by calculating the frequencies of all the characters of temp and comparing it with the character frequencies of sub-strings of S2 having length = length(temp)
This can be done with a single traversal by taking the first length(temp) characters of S2 and then for every iteration, add the frequency of the next character of the string and remove the frequency of the first character of the previously chosen sub-string until the complete string is traversed.
Below is the implementation of the above approach:

## C++

 `// C++ program to find the number of sub-strings``// of s1 which are anagram of any sub-string of s2` `#include ``using` `namespace` `std;` `#define ALL_CHARS 256` `// This function returns true if``// contents of arr1[] and arr2[]``// are same, otherwise false.``bool` `compare(``char``* arr1, ``char``* arr2)``{``    ``for` `(``int` `i = 0; i < ALL_CHARS; i++)``        ``if` `(arr1[i] != arr2[i])``            ``return` `false``;` `    ``return` `true``;``}` `// This function search for all permutations``// of string pat[] in string txt[]``bool` `search(string pat, string txt)``{``    ``int` `M = pat.length();``    ``int` `N = txt.length();` `    ``int` `i;` `    ``// countP[]: Store count of all characters``    ``// of pattern``    ``// countTW[]: Store count of current``    ``// window of text``    ``char` `countP[ALL_CHARS] = { 0 };``    ``char` `countTW[ALL_CHARS] = { 0 };``    ``for` `(i = 0; i < M; i++) {``        ``(countP[pat[i]])++;``        ``(countTW[txt[i]])++;``    ``}` `    ``// Traverse through remaining``    ``// characters of pattern``    ``for` `(i = M; i < N; i++) {` `        ``// Compare counts of current``        ``// window of text with``        ``// counts of pattern[]``        ``if` `(compare(countP, countTW)) {``            ``// cout<

## Java

 `// Java program to find the number of sub-Strings``// of s1 which are anagram of any sub-String of s2``class` `GFG {` `    ``static` `int` `MAX_LEN = ``1005``;``    ``static` `int` `MAX_CHAR = ``26``;` `    ``static` `int` `ALL_CHARS = ``256``;` `    ``// This function returns true if``    ``// contents of arr1[] and arr2[]``    ``// are same, otherwise false.``    ``static` `boolean` `compare(``char``[] arr1, ``char``[] arr2)``    ``{``        ``for` `(``int` `i = ``0``; i < ALL_CHARS; i++)``            ``if` `(arr1[i] != arr2[i])``                ``return` `false``;` `        ``return` `true``;``    ``}` `    ``// This function search for all permutations``    ``// of String pat[] in String txt[]``    ``static` `boolean` `search(String pat, String txt)``    ``{``        ``int` `M = pat.length();``        ``int` `N = txt.length();` `        ``int` `i;` `        ``// countP[]: Store count of all characters``        ``// of pattern``        ``// countTW[]: Store count of current``        ``// window of text``        ``char` `countP[] = ``new` `char``[ALL_CHARS];``        ``char` `countTW[] = ``new` `char``[ALL_CHARS];``        ``for` `(i = ``0``; i < M; i++) {``            ``(countP[pat.charAt(i)])++;``            ``(countTW[txt.charAt(i)])++;``        ``}` `        ``// Traverse through remaining``        ``// characters of pattern``        ``for` `(i = M; i < N; i++) {` `            ``// Compare counts of current``            ``// window of text with``            ``// counts of pattern[]``            ``if` `(compare(countP, countTW)) {``                ``// cout<

## Python3

 `# Python3 program to find the number of sub-strings``# of s1 which are anagram of any sub-string of s2``ALL_CHARS ``=` `256` `# This function returns true if``# contents of arr1[] and arr2[]``# are same, otherwise false.``def` `compare(arr1, arr2):``    ``for` `i ``in` `range``(ALL_CHARS):``        ``if` `arr1[i] !``=` `arr2[i]:``            ``return` `False``    ``return` `True` `# This function search for all permutations``# of string pat[] in string txt[]``def` `search(pat, txt):``    ``M ``=` `len``(pat)``    ``N ``=` `len``(txt)` `    ``# countP[]: Store count of all characters``    ``# of pattern``    ``# countTW[]: Store count of current``    ``# window of text``    ``countP ``=` `[``0``] ``*` `ALL_CHARS``    ``countTW ``=` `[``0``] ``*` `ALL_CHARS``    ``for` `i ``in` `range``(M):``        ``countP[``ord``(pat[i])] ``+``=` `1``        ``countTW[``ord``(txt[i])] ``+``=` `1` `    ``# Traverse through remaining``    ``# characters of pattern``    ``for` `i ``in` `range``(M, N):` `        ``# Compare counts of current``        ``# window of text with``        ``# counts of pattern[]``        ``if` `compare(countP, countTW):``            ``return` `True` `        ``# Add current character to current window``        ``countTW[``ord``(txt[i])] ``+``=` `1` `        ``# Remove the first character``        ``# of previous window``        ``countTW[``ord``(txt[i ``-` `M])] ``-``=` `1` `    ``# Check for the last window in text``    ``if` `compare(countP, countTW):``        ``return` `True` `    ``return` `False` `# Function to return the number of sub-strings of s1``# that are anagrams of any sub-string of s2``def` `calculateSubString(s1, s2, n):` `    ``# initializing variables``    ``count, j, x ``=` `0``, ``0``, ``0` `    ``# outer loop for picking starting point``    ``for` `i ``in` `range``(n):` `        ``# loop for different length of substrings``        ``for` `length ``in` `range``(``1``, n ``-` `i ``+` `1``):` `            ``# If s2 has any substring which is``            ``# anagram of s1.substr(i, len)``            ``if` `search(s1[i:i ``+` `length], s2):` `                ``# increment the count``                ``count ``+``=` `1` `    ``return` `count` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ``str1 ``=` `"PLEASEHELPIMTRAPPED"``    ``str2 ``=` `"INAKICKSTARTFACTORY"` `    ``length ``=` `len``(str1)` `    ``print``(calculateSubString(str1, str2, length))` `# This code is contributed by``# sanjeev2552`

## C#

 `// C# program to find the number of sub-Strings``// of s1 which are anagram of any sub-String of s2``using` `System;``using` `System.Collections.Generic;` `class` `GFG {` `    ``static` `int` `MAX_LEN = 1005;``    ``static` `int` `MAX_CHAR = 26;` `    ``static` `int` `ALL_CHARS = 256;` `    ``// This function returns true if``    ``// contents of arr1[] and arr2[]``    ``// are same, otherwise false.``    ``static` `bool` `compare(``char``[] arr1, ``char``[] arr2)``    ``{``        ``for` `(``int` `i = 0; i < ALL_CHARS; i++)``            ``if` `(arr1[i] != arr2[i])``                ``return` `false``;` `        ``return` `true``;``    ``}` `    ``// This function search for all permutations``    ``// of String pat[] in String txt[]``    ``static` `bool` `search(String pat, String txt)``    ``{``        ``int` `M = pat.Length;``        ``int` `N = txt.Length;` `        ``int` `i;` `        ``// countP[]: Store count of all characters``        ``// of pattern``        ``// countTW[]: Store count of current``        ``// window of text``        ``char``[] countP = ``new` `char``[ALL_CHARS];``        ``char``[] countTW = ``new` `char``[ALL_CHARS];``        ``for` `(i = 0; i < M; i++) {``            ``(countP[pat[i]])++;``            ``(countTW[txt[i]])++;``        ``}` `        ``// Traverse through remaining``        ``// characters of pattern``        ``for` `(i = M; i < N; i++) {` `            ``// Compare counts of current``            ``// window of text with``            ``// counts of pattern[]``            ``if` `(compare(countP, countTW)) {``                ``// cout<

## Javascript

 ``
Output:
`9`

Time Complexity:  O(N2)

Space Complexity:  O(M) where M is the maximum length of characters ALL_CHARS

My Personal Notes arrow_drop_up