Skip to content
Related Articles
Queries to find frequencies of a string within specified substrings
• Last Updated : 26 May, 2021

Given a string S and a matrix Q of queries, each specifying the starting and ending indices L( = Q[i]) and R( = Q[i]) respectively of a substring of S, the task is to find the frequency of string K in substring [L, R].

Note: The ranges follow the 1-based indexing.

Examples:

Input: S = “GFGFFGFG”, K = “GFG”, Q = {{1, 8}, {3, 5}, {5, 8}}
Output:

Explanation: For query 1, there are 2 (“GFG”) substrings from index 1 to index 8. One is from index 1 to 3 and the other is from index 6 to 8.
For query 2, there are 0 (“GFG”) substrings from index 3 to 5.
For query 3, there are 1 (“GFG”) substrings from index 5 to index 8. The one and only substring are from index 6 to 8.

Input: S = “ABCABCABABC”, K = “ABC”, Q = {{1, 6}, {5, 11}}
Output:

Naive Approach:
Run a loop from L to R for all the queries. Count occurrence of the string K and return count.

Time Complexity: O(length of Q * |S|).

Efficient Approach:
Pre-compute and store the frequency of K for every index. Now, for computing the frequency of the string in a range [L, R], we just need to calculate the difference between the frequency of K at index (R-1) and (L-1)

Below is the implementation of the above approach:

## C++

 `// C++ Program to find``// frequency of a string K``// in a substring [L, R] in S` `#include ``#define max_len 100005``using` `namespace` `std;` `// Store the frequency of``// string for each index``int` `cnt[max_len];` `// Compute and store frequencies``// for every index``void` `precompute(string s, string K)``{` `    ``int` `n = s.size();``    ``for` `(``int` `i = 0; i < n - 1; i++) {``        ``cnt[i + 1]``            ``= cnt[i]``              ``+ (s.substr(i, K.size()) == K);``    ``}``}` `// Driver Code``int` `main()``{``    ``string s = ``"ABCABCABABC"``;``    ``string K = ``"ABC"``;``    ``precompute(s, K);` `    ``vector > Q``        ``= { { 1, 6 }, { 5, 11 } };` `    ``for` `(``auto` `it : Q) {``        ``cout << cnt[it.second - 1]``                    ``- cnt[it.first - 1]``             ``<< endl;``    ``}` `    ``return` `0;``}`

## Java

 `// Java program to find``// frequency of a string K``// in a substring [L, R] in S``class` `GFG{``    ` `static` `int` `max_len = ``100005``;` `// Store the frequency of``// string for each index``static` `int` `cnt[] = ``new` `int``[max_len];` `// Compute and store frequencies``// for every index``public` `static` `void` `precompute(String s,``                              ``String K)``{``    ``int` `n = s.length();``    ` `    ``for``(``int` `i = ``0``; i < n - ``2``; i++)``    ``{``        ``cnt[i + ``1``] = cnt[i];``        ``if` `(s.substring(``            ``i, i + K.length()).equals(K))``        ``{``            ``cnt[i + ``1``] += ``1``;``        ``}``    ``}``    ``cnt[n - ``2` `+ ``1``] = cnt[n - ``2``];``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``String s = ``"ABCABCABABC"``;``    ``String K = ``"ABC"``;``    ``precompute(s, K);``  ` `    ``int` `Q[][] = { { ``1``, ``6` `}, { ``5``, ``11` `} };``    ` `    ``for``(``int` `it = ``0``; it < Q.length; it++)``    ``{``        ``System.out.println(cnt[Q[it][``1``] - ``1``] -``                           ``cnt[Q[it][``0``] - ``1``]);``    ``}``}``}` `// This code is contributed by divyesh072019`

## Python3

 `# Python3 Program to find``# frequency of a string K``# in a substring [L, R] in S``max_len ``=` `100005` `# Store the frequency of``# string for each index``cnt ``=` `[``0``] ``*` `max_len` `# Compute and store frequencies``# for every index``def` `precompute(s, K):` `    ``n ``=` `len``(s)``    ``for` `i ``in` `range``(n ``-` `1``):``        ``cnt[i ``+` `1``] ``=` `cnt[i]``        ``if` `s[i : ``len``(K) ``+` `i] ``=``=` `K:``            ``cnt[i ``+` `1``] ``+``=` `1` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``s ``=` `"ABCABCABABC"``    ``K ``=` `"ABC"``    ``precompute(s, K)``    ``Q ``=` `[[``1``, ``6``], [``5``, ``11``]]` `    ``for` `it ``in` `Q:``        ``print``(cnt[it[``1``] ``-` `1``] ``-``              ``cnt[it[``0``] ``-` `1``])` `# This code is contributed by Chitranayal`

## C#

 `// C# program to find frequency of``// a string K in a substring [L, R] in S``using` `System.IO;``using` `System;` `class` `GFG{``    ` `static` `int` `max_len = 100005;` `// Store the frequency of``// string for each index``static` `int``[] cnt = ``new` `int``[max_len];` `// Compute and store frequencies``// for every index``static` `void` `precompute(``string` `s,``string` `K)``{``    ``int` `n = s.Length;``    ` `    ``for``(``int` `i = 0; i < n - 2; i++)``    ``{``        ``cnt[i + 1] = cnt[i];``        ` `        ``if` `(s.Substring(i, K.Length).Equals(K))``        ``{``            ``cnt[i + 1] += 1;``        ``}``    ``}``    ``cnt[n - 2 + 1] = cnt[n - 2];``}` `// Driver code``static` `void` `Main()``{``    ``string` `s = ``"ABCABCABABC"``;``    ``string` `K = ``"ABC"``;``    ``precompute(s, K);``    ``int``[,] Q = { { 1, 6 }, { 5, 11 } };``    ` `    ``for``(``int` `it = 0; it < Q.GetLength(0); it++)``    ``{  ``        ``Console.WriteLine(cnt[Q[it, 1] - 1] -``                          ``cnt[Q[it, 0] - 1]);``    ``}``}``}` `// This code is contributed by rag2127`

## Javascript

 ``
Output:
```2
1```

Time Complexity: O( | S | + length of Q ), as every query is answered in O(1).
Auxiliary Space: O( |S| )

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 industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up