 GeeksforGeeks App
Open App Browser
Continue

# Count unique substrings of a string S present in a wraparound string

Given a string S which is an infinite wraparound string of the string “abcdefghijklmnopqrstuvwxyz”, the task is to count the number of unique non-empty substrings of a string p are present in s.

Examples:

Input: S = “zab”
Output: 6
Explanation: All possible substrings are “z”, “a”, “b”, “za”, “ab”, “zab”.

Input: S = “cac”
Output: 2
Explanation: All possible substrings are “a” and “c” only.

Approach: Follow the steps below to solve the problem

1. Iterate over each character of the string
2. Initialize an auxiliary array arr[] of size 26, to store the current length of substring that is present in string S starting from each character of string P.
3. Initialize a variable, say curLen, which stores the length of substring present in P including the current character if the current character is not a part of the previous substring.
4. Initialize a variable, say ans, to store the unique count of non-empty substrings of p present in S.
5. Iterate over the characters of the string and check for the following two cases:
• Check if the current character can be added with previous substring to form the required substring or not.
• Add the difference of curLen and arr[curr] to ans if (curLen + 1) is greater than arr[curr] to avoid repetition of substrings.
6. Print the value of ans.

Below is the implementation of the above approach:

## C++

 `// C++ program for``// the above approach` `#include ``using` `namespace` `std;` `// Function to find the count of``// non-empty substrings of p present in s``int` `findSubstringInWraproundString(string p)``{``    ``// Stores the required answer``    ``int` `ans = 0;` `    ``// Stores the length of``    ``// substring present in p``    ``int` `curLen = 0;` `    ``// Stores the current length``    ``// of substring that is``    ``// present in string s starting``    ``// from each character of p``    ``int` `arr = { 0 };` `    ``// Iterate over the characters of the string``    ``for` `(``int` `i = 0; i < (``int``)p.length(); i++) {` `        ``int` `curr = p[i] - ``'a'``;` `        ``// Check if the current character``        ``// can be added with previous substring``        ``// to form the required substring``        ``if` `(i > 0``            ``&& (p[i - 1]``                ``!= ((curr + 26 - 1) % 26 + ``'a'``))) {``            ``curLen = 0;``        ``}` `        ``// Increment current length``        ``curLen++;` `        ``if` `(curLen > arr[curr]) {` `            ``// To avoid repetition``            ``ans += (curLen - arr[curr]);` `            ``// Update arr[cur]``            ``arr[curr] = curLen;``        ``}``    ``}` `    ``// Print the answer``    ``cout << ans;``}` `// Driver Code``int` `main()``{``    ``string p = ``"zab"``;` `    ``// Function call to find the``    ``// count of non-empty substrings``    ``// of p present in s``    ``findSubstringInWraproundString(p);` `    ``return` `0;``}`

## Java

 `import` `java.util.*;``class` `GFG``{``  ` `    ``// Function to find the count of``    ``// non-empty substrings of p present in s``    ``static` `void` `findSubstringInWraproundString(String p)``    ``{``      ` `        ``// Stores the required answer``        ``int` `ans = ``0``;` `        ``// Stores the length of``        ``// substring present in p``        ``int` `curLen = ``0``;` `        ``// Stores the current length``        ``// of substring that is``        ``// present in string s starting``        ``// from each character of p``        ``int` `arr[] = ``new` `int``[``26``];` `        ``// Iterate over the characters of the string``        ``for` `(``int` `i = ``0``; i < p.length(); i++)``        ``{` `            ``int` `curr = p.charAt(i) - ``'a'``;` `            ``// Check if the current character``            ``// can be added with previous substring``            ``// to form the required substring``            ``if` `(i > ``0``                ``&& (p.charAt(i - ``1``)``                    ``!= ((curr + ``26` `- ``1``) % ``26` `+ ``'a'``)))``            ``{``                ``curLen = ``0``;``            ``}` `            ``// Increment current length``            ``curLen++;``            ``if` `(curLen > arr[curr])``            ``{` `                ``// To avoid repetition``                ``ans += (curLen - arr[curr]);` `                ``// Update arr[cur]``                ``arr[curr] = curLen;``            ``}``        ``}` `        ``// Print the answer``        ``System.out.println(ans);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{``        ``String p = ``"zab"``;` `        ``// Function call to find the``        ``// count of non-empty substrings``        ``// of p present in s``        ``findSubstringInWraproundString(p);``    ``}``}` `// This code is contributed by hemanth gadarla`

## Python3

 `# Python3 program for``# the above approach` `# Function to find the count of``# non-empty substrings of p present in s``def` `findSubstringInWraproundString(p) :` `    ``# Stores the required answer``    ``ans ``=` `0`` ` `    ``# Stores the length of``    ``# substring present in p``    ``curLen ``=` `0`` ` `    ``# Stores the current length``    ``# of substring that is``    ``# present in string s starting``    ``# from each character of p``    ``arr ``=` `[``0``]``*``26`` ` `    ``# Iterate over the characters of the string``    ``for` `i ``in` `range``(``0``, ``len``(p)) :`` ` `        ``curr ``=` `ord``(p[i]) ``-` `ord``(``'a'``)`` ` `        ``# Check if the current character``        ``# can be added with previous substring``        ``# to form the required substring``        ``if` `(i > ``0` `and` `(``ord``(p[i ``-` `1``]) !``=` `((curr ``+` `26` `-` `1``) ``%` `26` `+` `ord``(``'a'``)))) :``            ``curLen ``=` `0`` ` `        ``# Increment current length``        ``curLen ``+``=` `1`` ` `        ``if` `(curLen > arr[curr]) :`` ` `            ``# To avoid repetition``            ``ans ``+``=` `(curLen ``-` `arr[curr])`` ` `            ``# Update arr[cur]``            ``arr[curr] ``=` `curLen`` ` `    ``# Print the answer``    ``print``(ans)``    ` `p ``=` `"zab"`` ` `# Function call to find the``# count of non-empty substrings``# of p present in s``findSubstringInWraproundString(p)` `# This code is contributed by divyeshrabadiya07.`

## C#

 `// C# program for``// the above approach``using` `System;``class` `GFG``{` `  ``// Function to find the count of``  ``// non-empty substrings of p present in s``  ``static` `void` `findSubstringInWraproundString(``string` `p)``  ``{``    ` `    ``// Stores the required answer``    ``int` `ans = 0;` `    ``// Stores the length of``    ``// substring present in p``    ``int` `curLen = 0;` `    ``// Stores the current length``    ``// of substring that is``    ``// present in string s starting``    ``// from each character of p``    ``int``[] arr = ``new` `int``;` `    ``// Iterate over the characters of the string``    ``for` `(``int` `i = 0; i < (``int``)p.Length; i++)``    ``{``      ``int` `curr = p[i] - ``'a'``;` `      ``// Check if the current character``      ``// can be added with previous substring``      ``// to form the required substring``      ``if` `(i > 0 && (p[i - 1] != ((curr + 26 - 1) % 26 + ``'a'``)))``      ``{``        ``curLen = 0;``      ``}` `      ``// Increment current length``      ``curLen++;``      ``if` `(curLen > arr[curr])``      ``{` `        ``// To avoid repetition``        ``ans += (curLen - arr[curr]);` `        ``// Update arr[cur]``        ``arr[curr] = curLen;``      ``}``    ``}` `    ``// Print the answer``    ``Console.Write(ans);``  ``}` `  ``// Driver code``  ``static` `void` `Main()``  ``{``    ``string` `p = ``"zab"``;` `    ``// Function call to find the``    ``// count of non-empty substrings``    ``// of p present in s``    ``findSubstringInWraproundString(p);``  ``}``}` `// This code is contributed by divyesh072019.`

## Javascript

 ``

Output

`6`

Time Complexity: O(N)
Auxiliary Space: O(1)

## Method 2:

### Approach Steps:

1. Initialize a dictionary to store the count of distinct substrings starting with each letter of the English alphabet.
2. Initialize the length of the longest increasing substring ending at each position in the given string ‘p’ to 0.
3. Iterate over the characters of ‘p’ and update the length of the longest increasing substring ending at each position using dynamic programming.
4. Update the count of distinct substrings starting with each letter of ‘p’ based on the length of the longest increasing substring ending at each position.
5. Return the sum of counts for all letters.

## C++

 `#include ``#include ``using` `namespace` `std;` `int` `countSubstringsInWraparoundString(string p) {``    ``// Initialize an array to store the count``    ``// of distinct substrings starting with each letter``    ``int` `count;``    ``memset``(count, 0, ``sizeof``(count));``    ` `    ``// Initialize the length of the longest increasing``    ``// substring ending at each position to 0``    ``int` `len_inc_substring[p.length()];``    ``memset``(len_inc_substring, 0, ``sizeof``(len_inc_substring));``    ` `    ``// Iterate over the characters of the string``    ``for` `(``int` `i = 0; i < p.length(); i++) {``        ``// Update the length of the longest increasing``        ``// substring ending at the current position``        ``if` `(i > 0 && (p[i] - p[i-1] + 26) % 26 == 1) {``            ``len_inc_substring[i] = len_inc_substring[i-1] + 1;``        ``}``        ``else` `{``            ``len_inc_substring[i] = 1;``        ``}``            ` `        ``// Update the count of distinct substrings``        ``// starting with the current letter``        ``count[p[i]-``'a'``] = max(count[p[i]-``'a'``], len_inc_substring[i]);``    ``}``        ` `    ``// Return the sum of counts for all letters``    ``int` `total_count = 0;``    ``for` `(``int` `i = 0; i < 26; i++) {``        ``total_count += count[i];``    ``}``    ``return` `total_count;``}` `int` `main() {``    ``string p = ``"zab"``;``    ``cout << countSubstringsInWraparoundString(p) << endl; ``// Output: 6``    ``return` `0;``}`

## Java

 `// Java code to count the number of distinct substrings in a wraparound string` `import` `java.util.Arrays;` `public` `class` `Main {``    ``public` `static` `int` `countSubstringsInWraparoundString(String p) {``        ``// Initialize an array to store the count``        ``// of distinct substrings starting with each letter``        ``int``[] count = ``new` `int``[``26``];``        ``Arrays.fill(count, ``0``);``        ` `        ``// Initialize the length of the longest increasing``        ``// substring ending at each position to 0``        ``int``[] len_inc_substring = ``new` `int``[p.length()];``        ``Arrays.fill(len_inc_substring, ``0``);``        ` `        ``// Iterate over the characters of the string``        ``for` `(``int` `i = ``0``; i < p.length(); i++) {``            ``// Update the length of the longest increasing``            ``// substring ending at the current position``            ``if` `(i > ``0` `&& (p.charAt(i) - p.charAt(i-``1``) + ``26``) % ``26` `== ``1``) {``                ``len_inc_substring[i] = len_inc_substring[i-``1``] + ``1``;``            ``}``            ``else` `{``                ``len_inc_substring[i] = ``1``;``            ``}``                ` `            ``// Update the count of distinct substrings``            ``// starting with the current letter``            ``count[p.charAt(i)-``'a'``] = Math.max(count[p.charAt(i)-``'a'``], len_inc_substring[i]);``        ``}``            ` `        ``// Return the sum of counts for all letters``        ``int` `total_count = ``0``;``        ``for` `(``int` `i = ``0``; i < ``26``; i++) {``            ``total_count += count[i];``        ``}``        ``return` `total_count;``    ``}` `    ``public` `static` `void` `main(String[] args) {``        ``String p = ``"zab"``;``        ``System.out.println(countSubstringsInWraparoundString(p)); ``// Output: 6``    ``}``}`

## Python3

 `def` `countSubstringsInWraparoundString(p):``    ``# Initialize a dictionary to store the count``    ``# of distinct substrings starting with each letter``    ``count ``=` `{``chr``(i): ``0` `for` `i ``in` `range``(``ord``(``'a'``), ``ord``(``'z'``)``+``1``)}``    ` `    ``# Initialize the length of the longest increasing``    ``# substring ending at each position to 0``    ``len_inc_substring ``=` `[``0``] ``*` `len``(p)``    ` `    ``# Iterate over the characters of the string``    ``for` `i ``in` `range``(``len``(p)):``        ``# Update the length of the longest increasing``        ``# substring ending at the current position``        ``if` `i > ``0` `and` `(``ord``(p[i]) ``-` `ord``(p[i``-``1``])) ``%` `26` `=``=` `1``:``            ``len_inc_substring[i] ``=` `len_inc_substring[i``-``1``] ``+` `1``        ``else``:``            ``len_inc_substring[i] ``=` `1``            ` `        ``# Update the count of distinct substrings``        ``# starting with the current letter``        ``count[p[i]] ``=` `max``(count[p[i]], len_inc_substring[i])``        ` `    ``# Return the sum of counts for all letters``    ``return` `sum``(count.values())` `# Test the function with a sample input``p ``=` `"zab"``print``(countSubstringsInWraparoundString(p)) ``# Output: 6`

## C#

 `using` `System;` `public` `class` `MainClass {``    ``public` `static` `int``    ``CountSubstringsInWraparoundString(``string` `p)``    ``{``        ``// Initialize an array to store the count``        ``// of distinct substrings starting with each letter``        ``int``[] count = ``new` `int``;``        ``Array.Fill(count, 0);` `        ``// Initialize the length of the longest increasing``        ``// substring ending at each position to 0``        ``int``[] len_inc_substring = ``new` `int``[p.Length];``        ``Array.Fill(len_inc_substring, 0);` `        ``// Iterate over the characters of the string``        ``for` `(``int` `i = 0; i < p.Length; i++) {``            ``// Update the length of the longest increasing``            ``// substring ending at the current position``            ``if` `(i > 0 && (p[i] - p[i - 1] + 26) % 26 == 1) {``                ``len_inc_substring[i]``                    ``= len_inc_substring[i - 1] + 1;``            ``}``            ``else` `{``                ``len_inc_substring[i] = 1;``            ``}` `            ``// Update the count of distinct substrings``            ``// starting with the current letter``            ``count[p[i] - ``'a'``] = Math.Max(``                ``count[p[i] - ``'a'``], len_inc_substring[i]);``        ``}` `        ``// Return the sum of counts for all letters``        ``int` `total_count = 0;``        ``for` `(``int` `i = 0; i < 26; i++) {``            ``total_count += count[i];``        ``}``        ``return` `total_count;``    ``}` `    ``public` `static` `void` `Main()``    ``{``        ``string` `p = ``"zab"``;``        ``Console.WriteLine(CountSubstringsInWraparoundString(``            ``p)); ``// Output: 6``    ``}``}`

## Javascript

 `function` `countSubstringsInWraparoundString(p) {``    ``// Initialize a dictionary to store the count``    ``// of distinct substrings starting with each letter``    ``let count = {};``    ``for` `(let i = ``'a'``.charCodeAt(0); i <= ``'z'``.charCodeAt(0); i++) {``        ``count[String.fromCharCode(i)] = 0;``    ``}``    ` `    ``// Initialize the length of the longest increasing``    ``// substring ending at each position to 0``    ``let len_inc_substring = ``new` `Array(p.length).fill(0);``    ` `    ``// Iterate over the characters of the string``    ``for` `(let i = 0; i < p.length; i++) {``        ``// Update the length of the longest increasing``        ``// substring ending at the current position``        ``if` `(i > 0 && (p.charCodeAt(i) - p.charCodeAt(i-1) + 26) % 26 == 1) {``            ``len_inc_substring[i] = len_inc_substring[i-1] + 1;``        ``} ``else` `{``            ``len_inc_substring[i] = 1;``        ``}``        ` `        ``// Update the count of distinct substrings starting with the current letter``        ``count[p[i]] = Math.max(count[p[i]], len_inc_substring[i]);``    ``}``    ` `    ``// Return the sum of counts for all letters``    ``return` `Object.values(count).reduce((a,b) => a+b);``}` `// Test the function with a sample input``let p = ``"zab"``;``console.log(countSubstringsInWraparoundString(p)); ``// Output: 6`

Output

`6`

### Time Complexity:

The time complexity of this approach is O(n), where n is the length of the input string ‘p’. This is because we iterate over the characters of ‘p’ only once.

### Auxiliary Space:

The auxiliary space of this approach is O(26), which is constant. This is because we use a dictionary to store the count of distinct substrings starting with each letter of the English alphabet, and the size of the dictionary is fixed at 26. We also use a list of size n to store the length of the longest increasing substring ending at each position in ‘p’. Therefore, the total auxiliary space used by the algorithm is O(26 + n), which is equivalent to O(n).

My Personal Notes arrow_drop_up