# Find the longest sub-string which is prefix, suffix and also present inside the string | Set 2

Given string str. The task is to find the longest sub-string which is a prefix, a suffix and a sub-string of the given string, str. If no such string exists then print -1.

Examples:

Input: str = “geeksisforgeeksinplatformgeeks”
Output: geeks

Input: str = “fixprefixsuffix”
Output: fix

Approach:

• First we are calculating the Z array by using the Z algorithm.
• Update the values in Bit array by 1 from index z[i].
• Querying for the maximum length needed substring using the pref function.
• If len is 0 then such substring is not possible from the given string.

Below is the implementation approach:

## C++

 `// C++ program to find that ` `// substring which is its ` `// suffix prefix and also ` `// found somewhere in betweem ` `#include ` `using` `namespace` `std; ` ` `  `// Z-algorithm function ` `vector<``int``> z_function(string s) ` `{ ` `    ``int` `n = s.size(); ` `    ``vector<``int``> z(n); ` `    ``for` `(``int` `i = 1, l = 0, ` `             ``r = 0; ` `         ``i < n; ` `         ``i++) { ` `        ``if` `(i <= r) ` `            ``z[i] = min(r - i + 1, ` `                       ``z[i - l]); ` ` `  `        ``while` `(i + z[i] < n ` `               ``&& s[z[i]] == s[i + z[i]]) ` `            ``z[i]++; ` ` `  `        ``if` `(i + z[i] - 1 > r) ` `            ``l = i, r = i + z[i] - 1; ` `    ``} ` `    ``return` `z; ` `} ` ` `  `int` `n, len = 0; ` ` `  `// BIT array ` `int` `bit; ` ` `  `string s; ` `vector<``int``> z; ` `map<``int``, ``int``> m; ` ` `  `// bit update function which ` `// updates values from index ` `// "idx" to last by value "val" ` `void` `update(``int` `idx, ``int` `val) ` `{ ` `    ``if` `(idx == 0) ` `        ``return``; ` `    ``while` `(idx <= n) { ` `        ``bit[idx] += val; ` `        ``idx += (idx & -idx); ` `    ``} ` `} ` ` `  `// Query function in bit ` `int` `pref(``int` `idx) ` `{ ` `    ``int` `ans = 0; ` `    ``while` `(idx > 0) { ` `        ``ans += bit[idx]; ` `        ``idx -= (idx & -idx); ` `    ``} ` `    ``return` `ans; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``s = ``"geeksisforgeeksinplatformgeeks"``; ` `    ``n = s.size(); ` ` `  `    ``// Making the z array ` `    ``z = z_function(s); ` ` `  `    ``// update in the bit array from ` `    ``// index z[i] by increment of 1 ` `    ``for` `(``int` `i = 1; i < n; i++) { ` `        ``update(z[i], 1); ` `    ``} ` ` `  `    ``for` `(``int` `i = n - 1; i > 1; i--) { ` `        ``// if the value in z[i] is ` `        ``// not equal to (n-i) then no ` `        ``// need to move further ` `        ``if` `(z[i] != (n - i)) ` `            ``continue``; ` ` `  `        ``// queryng for the maximum ` `        ``// length substring from ` `        ``// bit array ` `        ``if` `(pref(n) - pref(z[i] - 1) >= 2) { ` `            ``len = max(len, z[i]); ` `        ``} ` `    ``} ` ` `  `    ``if` `(!len) ` `        ``cout << ``"-1"``; ` `    ``else` `        ``cout << s.substr(0, len); ` `    ``return` `0; ` `} `

## Java

 `// Java program to find that ` `// substring which is its ` `// suffix prefix and also ` `// found somewhere in betweem ` `class` `GFG ` `{ ` ` `  `// Z-algorithm function ` `static` `int``[] z_function(``char` `[]s) ` `{ ` `    ``int` `n = s.length; ` `    ``int` `[]z = ``new` `int``[n]; ` `    ``for` `(``int` `i = ``1``, l = ``0``, r = ``0``;  ` `             ``i < n; i++)  ` `    ``{ ` `        ``if` `(i <= r) ` `            ``z[i] = Math.min(r - i + ``1``, ` `                            ``z[i - l]); ` ` `  `        ``while` `(i + z[i] < n && ` `                 ``s[z[i]] == s[i + z[i]]) ` `            ``z[i]++; ` ` `  `        ``if` `(i + z[i] - ``1` `> r) ` `        ``{ ` `            ``l = i; r = i + z[i] - ``1``; ` `        ``} ` `    ``} ` `    ``return` `z; ` `} ` ` `  `static` `int` `n, len = ``0``; ` ` `  `// BIT array ` `static` `int` `[]bit = ``new` `int``[``1000005``]; ` ` `  `static` `String s; ` `static` `int``[] z; ` ` `  `// bit update function which ` `// updates values from index ` `// "idx" to last by value "val" ` `static` `void` `update(``int` `idx, ``int` `val) ` `{ ` `    ``if` `(idx == ``0``) ` `        ``return``; ` `    ``while` `(idx <= n) ` `    ``{ ` `        ``bit[idx] += val; ` `        ``idx += (idx & -idx); ` `    ``} ` `} ` ` `  `// Query function in bit ` `static` `int` `pref(``int` `idx) ` `{ ` `    ``int` `ans = ``0``; ` `    ``while` `(idx > ``0``) ` `    ``{ ` `        ``ans += bit[idx]; ` `        ``idx -= (idx & -idx); ` `    ``} ` `    ``return` `ans; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``s = ``"geeksisforgeeksinplatformgeeks"``; ` `    ``z = ``new` `int``[s.length()]; ` `    ``n = s.length(); ` ` `  `    ``// Making the z array ` `    ``z = z_function(s.toCharArray()); ` ` `  `    ``// update in the bit array from ` `    ``// index z[i] by increment of 1 ` `    ``for` `(``int` `i = ``1``; i < n; i++)  ` `    ``{ ` `        ``update(z[i], ``1``); ` `    ``} ` ` `  `    ``for` `(``int` `i = n - ``1``; i > ``1``; i--) ` `    ``{ ` `        ``// if the value in z[i] is ` `        ``// not equal to (n-i) then no ` `        ``// need to move further ` `        ``if` `(z[i] != (n - i)) ` `            ``continue``; ` ` `  `        ``// queryng for the maximum ` `        ``// length substring from ` `        ``// bit array ` `        ``if` `(pref(n) - pref(z[i] - ``1``) >= ``2``)  ` `        ``{ ` `            ``len = Math.max(len, z[i]); ` `        ``} ` `    ``} ` ` `  `    ``if` `(len == ``0``) ` `        ``System.out.println(``"-1"``); ` `    ``else` `        ``System.out.println(s.substring(``0``, len)); ` `} ` `} ` ` `  `// This code is contributed  ` `// by PrinciRaj1992 `

## Python3

 `# Python3 program to find that ` `# substring which is its ` `# suffix prefix and also ` `# found somewhere in betweem ` ` `  `# Z-algorithm function ` `def` `z_function(s): ` `    ``global` `z, n ` `    ``n ``=` `len``(s) ` `    ``z ``=` `[``0``] ``*` `n ` `    ``l, r ``=` `0``, ``0` `    ``for` `i ``in` `range``(``1``, n): ` `        ``if` `i <``=` `r: ` `            ``z[i] ``=` `min``(r ``-` `i ``+` `1``, z[i ``-` `1``]) ` ` `  `        ``while` `(i ``+` `z[i] < n ``and` `s[z[i]] ``=``=` `s[i ``+` `z[i]]): ` `            ``z[i] ``+``=` `1` ` `  `        ``if` `(i ``+` `z[i] ``-` `1` `> r): ` `            ``l ``=` `i ` `            ``r ``=` `i ``+` `z[i] ``-` `1` `    ``return` `z ` ` `  `# bit update function which ` `# updates values from index ` `# "idx" to last by value "val" ` `def` `update(idx, val): ` `    ``global` `bit ` `    ``if` `idx ``=``=` `0``: ` `        ``return` `    ``while` `idx <``=` `n: ` `        ``bit[idx] ``+``=` `val ` `        ``idx ``+``=` `(idx & ``-``idx) ` ` `  `# Query function in bit ` `def` `pref(idx): ` `    ``global` `bit ` `    ``ans ``=` `0` `    ``while` `idx > ``0``: ` `        ``ans ``+``=` `bit[idx] ` `        ``idx ``-``=` `(idx & ``-``idx) ` ` `  `    ``return` `ans ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``: ` `    ``n ``=` `0` `    ``length ``=` `0` ` `  `    ``# BIT array ` `    ``bit ``=` `[``0``] ``*` `1000005` `    ``z ``=` `[] ` `    ``m ``=` `dict``() ` ` `  `    ``s ``=` `"geeksisforgeeksinplatformgeeks"` ` `  `    ``# Making the z array ` `    ``z ``=` `z_function(s) ` ` `  `    ``# update in the bit array from ` `    ``# index z[i] by increment of 1 ` `    ``for` `i ``in` `range``(``1``, n): ` `        ``update(z[i], ``1``) ` ` `  `    ``for` `i ``in` `range``(n ``-` `1``, ``1``, ``-``1``): ` ` `  `        ``# if the value in z[i] is ` `        ``# not equal to (n-i) then no ` `        ``# need to move further ` `        ``if` `z[i] !``=` `n ``-` `i: ` `            ``continue` ` `  `        ``# queryng for the maximum ` `        ``# length substring from ` `        ``# bit array ` `        ``if` `(pref(n) ``-` `pref(z[i] ``-` `1``)) >``=` `2``: ` `            ``length ``=` `max``(length, z[i]) ` ` `  `    ``if` `not` `length: ` `        ``print``(``-``1``) ` `    ``else``: ` `        ``print``(s[:length]) ` ` `  `# This code is contributed by ` `# sanjeev2552 `

## C#

 `// C# program to find that ` `// substring which is its ` `// suffix prefix and also ` `// found somewhere in betweem ` `using` `System; ` ` `  `class` `GFG ` `{ ` ` `  `// Z-algorithm function ` `static` `int``[] z_function(``char` `[]s) ` `{ ` `    ``int` `n = s.Length; ` `    ``int` `[]z = ``new` `int``[n]; ` `    ``for` `(``int` `i = 1, l = 0, r = 0;  ` `             ``i < n; i++)  ` `    ``{ ` `        ``if` `(i <= r) ` `            ``z[i] = Math.Min(r - i + 1, ` `                            ``z[i - l]); ` ` `  `        ``while` `(i + z[i] < n && ` `                 ``s[z[i]] == s[i + z[i]]) ` `            ``z[i]++; ` ` `  `        ``if` `(i + z[i] - 1 > r) ` `        ``{ ` `            ``l = i; r = i + z[i] - 1; ` `        ``} ` `    ``} ` `    ``return` `z; ` `} ` ` `  `static` `int` `n, len = 0; ` ` `  `// BIT array ` `static` `int` `[]bit = ``new` `int``; ` `static` `String s; ` `static` `int``[] z; ` ` `  `// bit update function which ` `// updates values from index ` `// "idx" to last by value "val" ` `static` `void` `update(``int` `idx, ``int` `val) ` `{ ` `    ``if` `(idx == 0) ` `        ``return``; ` `    ``while` `(idx <= n) ` `    ``{ ` `        ``bit[idx] += val; ` `        ``idx += (idx & -idx); ` `    ``} ` `} ` ` `  `// Query function in bit ` `static` `int` `pref(``int` `idx) ` `{ ` `    ``int` `ans = 0; ` `    ``while` `(idx > 0) ` `    ``{ ` `        ``ans += bit[idx]; ` `        ``idx -= (idx & -idx); ` `    ``} ` `    ``return` `ans; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``s = ``"geeksisforgeeksinplatformgeeks"``; ` `    ``z = ``new` `int``[s.Length]; ` `    ``n = s.Length; ` ` `  `    ``// Making the z array ` `    ``z = z_function(s.ToCharArray()); ` ` `  `    ``// update in the bit array from ` `    ``// index z[i] by increment of 1 ` `    ``for` `(``int` `i = 1; i < n; i++)  ` `    ``{ ` `        ``update(z[i], 1); ` `    ``} ` ` `  `    ``for` `(``int` `i = n - 1; i > 1; i--) ` `    ``{ ` `        ``// if the value in z[i] is ` `        ``// not equal to (n-i) then no ` `        ``// need to move further ` `        ``if` `(z[i] != (n - i)) ` `            ``continue``; ` ` `  `        ``// queryng for the maximum ` `        ``// length substring from ` `        ``// bit array ` `        ``if` `(pref(n) - pref(z[i] - 1) >= 2)  ` `        ``{ ` `            ``len = Math.Max(len, z[i]); ` `        ``} ` `    ``} ` ` `  `    ``if` `(len == 0) ` `        ``Console.WriteLine(``"-1"``); ` `    ``else` `        ``Console.WriteLine(s.Substring(0, len)); ` `} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

Output:

```geeks
```

Time complexity: O(N)

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : princiraj1992, sanjeev2552

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.