Open in App
Not now

# Longest prefix which is also suffix

Given a string s, find the length of the longest prefix, which is also a suffix. The prefix and suffix should not overlap.

Examples:

```Input : aabcdaabc
Output : 4
The string "aabc" is the longest
prefix which is also suffix.

Input : abcab
Output : 2

Input : aaaa
Output : 2```
Recommended Practice

Simple Solution: Since overlapping prefixes and suffixes is not allowed, we break the string from the middle and start matching left and right strings. If they are equal return size of one string, else they try for shorter lengths on both sides.
Below is a solution to the above approach!

## C++

 `// CPP program to find length of the` `// longest prefix which is also suffix` `#include ` `using` `namespace` `std;`   `// Function to find largest prefix ` `// which is also a suffix` `int` `largest_prefix_suffix(``const` `std::string ` `                                      ``&str) ` `{` `  `  `  ``int` `n = str.length();` `  `  `  ``// if n is less than 2` `  ``if``(n < 2) {` `    ``return` `0;` `  ``}`   `  ``int` `len = 0;` `  ``int` `i = 1;` `  `  `  ``// Iterate i till n` `  ``while``(i < n)` `  ``{` `    `  `    ``// If str[i] is equal to ` `    ``// str[len]` `    ``if``(str[i] == str[len]) ` `    ``{` `      ``++len;` `      ``++i;` `    ``}` `    ``else` `    ``{` `      ``i = i - len + 1;` `      ``len = 0;` `    ``}` `  ``}` `  `  `  ``// Return len` `  ``return` `len>n/2? len/2:len;`   `}`   `// Driver code` `int` `main() ` `{` `    `  `  ``string s = ``"blablabla"``;`   `  ``// Function Call` `  ``cout << largest_prefix_suffix(s);` `  ``return` `0;` `}`

## Java

 `// Java program to find length of the longest` `// prefix which is also suffix` `class` `GFG ` `{` `    `  `   ``// Function to find largest prefix ` `   ``// which is also a suffix` `   ``static` `int` `longestPrefixSuffix(String s) ` `   ``{` `      ``int` `n = s.length();`   `      ``// If n is less than 2` `      ``if``(n < ``2``) {` `          ``return` `0``;` `      ``}`   `      ``int` `len = ``0``;` `      ``int` `i = (n + ``1``)/``2``;`   `      ``// Iterate i till n` `      ``while``(i < n)` `      ``{`   `        ``// If s.charAt(i) is equal to ` `        ``// s.charAt(len)` `        ``if``(s.charAt(i) == s.charAt(len)) ` `        ``{` `          ``++len;` `          ``++i;` `        ``}` `        ``else` `        ``{` `          ``i = i - len + ``1``;` `          ``len = ``0``;` `        ``}` `      ``}`   `      ``// Return len` `      ``return` `len;`   `  ``}` `    `  `    ``// Driver code` `  ``public` `static` `void` `main (String[] args) ` `  ``{` `    ``String s = ``"abcaabc"``;` `    ``System.out.println(longestPrefixSuffix(s));` `  ``}` `}`   `// This code is contributed by Anant Agarwal.`

## Python3

 `# Python3 program to find length ` `# of the longest prefix which ` `# is also suffix` `def` `longestPrefixSuffix(s) :` `    ``n ``=` `len``(s)` `    `  `    ``for` `res ``in` `range``(n ``/``/` `2``, ``0``, ``-``1``) :` `        `  `        ``# Check for shorter lengths` `        ``# of first half.` `        ``prefix ``=` `s[``0``: res]` `        ``suffix ``=` `s[n ``-` `res: n]` `        `  `        ``if` `(prefix ``=``=` `suffix) :` `            ``return` `res` `            `    `    ``# if no prefix and suffix match ` `    ``# occurs` `    ``return` `0` `    `  `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    ``s ``=` `"blablabla"` `    ``print``(longestPrefixSuffix(s))`   `# This code is contributed by Nikita Tiwari.`

## C#

 `// C# program to find length of the longest` `// prefix which is also suffix` `using` `System;`   `class` `GFG ` `{` `    `  `    ``// Function to find largest prefix ` `    ``// which is also a suffix` `    ``static` `int` `longestPrefixSuffix(String s) ` `    ``{` `        ``int` `n = s.Length;` `    `  `        ``// if n is less than 2` `        ``if``(n < 2) {` `          ``return` `0;` `        ``}`   `        ``int` `len = 0;` `        ``int` `i = (n + 1)/2;`   `        ``// Iterate i till n` `        ``while``(i < n)` `        ``{`   `          ``// If str[i] is equal to ` `          ``// str[len]` `          ``if``(str[i] == str[len]) ` `          ``{` `            ``++len;` `            ``++i;` `          ``}` `          ``else` `          ``{` `            ``i = i - len + 1;` `            ``len = 0;` `          ``}` `        ``}`   `        ``// Return len` `        ``return` `len;` `    ``}` `    `  `    ``// Driver code` `    ``public` `static` `void` `Main () ` `    ``{` `        ``String s = ``"blablabla"``;` `        `  `        ``Console.WriteLine(longestPrefixSuffix(s));` `    ``}` `}`   `// This code is contributed by vt_m.`

## Javascript

 ``

Output:

`3`

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

Efficient Solution: The idea is to use the preprocessing algorithm KMP search. In the preprocessing algorithm, we build lps array which stores the following values.

lps[i] = the longest proper prefix of pat[0..i]
which is also a suffix of pat[0..i].

## C++

 `// Efficient CPP program to find length of ` `// the longest prefix which is also suffix` `#include` `using` `namespace` `std;`   `// Returns length of the longest prefix` `// which is also suffix and the two do` `// not overlap. This function mainly is` `// copy computeLPSArray() of in below post` `// https://www.geeksforgeeks.org/searching-for-patterns-set-2-kmp-algorithm/` `int` `longestPrefixSuffix(string s)` `{` `    ``int` `n = s.length();`   `    ``int` `lps[n];` `    ``lps[0] = 0; ``// lps[0] is always 0`   `    ``// length of the previous` `    ``// longest prefix suffix` `    ``int` `len = 0;`   `    ``// the loop calculates lps[i]` `    ``// for i = 1 to n-1` `    ``int` `i = (n+1)/2;` `    ``while` `(i < n)` `    ``{` `        ``if` `(s[i] == s[len])` `        ``{` `            ``len++;` `            ``lps[i] = len;` `            ``i++;` `        ``}` `        ``else` `// (pat[i] != pat[len])` `        ``{` `            ``// This is tricky. Consider` `            ``// the example. AAACAAAA` `            ``// and i = 7. The idea is` `            ``// similar to search step.` `            ``if` `(len != 0)` `            ``{` `                ``len = lps[len-1];`   `                ``// Also, note that we do` `                ``// not increment i here` `            ``}` `            ``else` `// if (len == 0)` `            ``{` `                ``lps[i] = 0;` `                ``i++;` `            ``}` `        ``}` `    ``}`   `    ``int` `res = lps[n-1];`   `    ``// Since we are looking for` `    ``// non overlapping parts.` `    ``return` `res;` `}`   `// Driver program to test above function` `int` `main()` `{` `    ``string s = ``"bbabbabb"``;` `    ``cout << longestPrefixSuffix(s);` `    ``return` `0;` `}`   `// Corrected by Nilanshu Yadav`

## Java

 `// Efficient Java program to find length of ` `// the longest prefix which is also suffix`   `class` `GFG ` `{` `    ``// Returns length of the longest prefix` `    ``// which is also suffix and the two do` `    ``// not overlap. This function mainly is` `    ``// copy computeLPSArray() of in below post` `    ``// https://www.geeksforgeeks.org/searching-` `    ``// for-patterns-set-2-kmp-algorithm/` `    ``static` `int` `longestPrefixSuffix(String s)` `    ``{` `        ``int` `n = s.length();` `    `  `        ``int` `lps[] = ``new` `int``[n];` `        `  `        ``// lps[0] is always 0` `        ``lps[``0``] = ``0``; ` `    `  `        ``// length of the previous` `        ``// longest prefix suffix` `        ``int` `len = ``0``;` `    `  `        ``// the loop calculates lps[i]` `        ``// for i = 1 to n-1` `        ``int` `i = (n+``1``)/``2``;` `        ``while` `(i < n)` `        ``{` `            ``if` `(s.charAt(i) == s.charAt(len))` `            ``{` `                ``len++;` `                ``lps[i] = len;` `                ``i++;` `            ``}` `            `  `             ``// (pat[i] != pat[len])` `            ``else` `            ``{` `                ``// This is tricky. Consider` `                ``// the example. AAACAAAA` `                ``// and i = 7. The idea is` `                ``// similar to search step.` `                ``if` `(len != ``0``)` `                ``{` `                    ``len = lps[len-``1``];` `    `  `                    ``// Also, note that we do` `                    ``// not increment i here` `                ``}` `                `  `                ``// if (len == 0)` `                ``else` `                ``{` `                    ``lps[i] = ``0``;` `                    ``i++;` `                ``}` `            ``}` `        ``}` `    `  `        ``int` `res = lps[n-``1``];` `    `  `        ``// Since we are looking for` `        ``// non overlapping parts.` `        ``return` `res;` `    ``}` `    `  `    ``// Driver program ` `    ``public` `static` `void` `main (String[] args) ` `    ``{` `        ``String s = ``"bbabbabb"``;` `        ``System.out.println(longestPrefixSuffix(s));` `    ``}` `}`   `// This code is contributed by Anant Agarwal.` `// Corrected by Nilanshu Yadav`

## Python3

 `# Efficient Python 3 program` `# to find length of ` `# the longest prefix ` `# which is also suffix`   `# Returns length of the longest prefix` `# which is also suffix and the two do` `# not overlap. This function mainly is` `# copy computeLPSArray() of in below post` `# https://www.geeksforgeeks.org/searching-for-patterns-set-2-kmp-algorithm/` `def` `longestPrefixSuffix(s) :` `    ``n ``=` `len``(s)` `    ``lps ``=` `[``0``] ``*` `n   ``# lps[0] is always 0` ` `  `    ``# length of the previous` `    ``# longest prefix suffix` `    ``l ``=` `0` `    `  `    ``# the loop calculates lps[i]` `    ``# for i = 1 to n-1` `    ``i ``=` `(n``+``1``)``/``/``2``;` `    ``while` `(i < n) :` `        ``if` `(s[i] ``=``=` `s[l]) :` `            ``l ``=` `l ``+` `1` `            ``lps[i] ``=` `l` `            ``i ``=` `i ``+` `1` `        `  `        ``else` `:`   `            ``# (pat[i] != pat[len])` `            ``# This is tricky. Consider` `            ``# the example. AAACAAAA` `            ``# and i = 7. The idea is` `            ``# similar to search step.` `            ``if` `(l !``=` `0``) :` `                ``l ``=` `lps[l``-``1``]` ` `  `                ``# Also, note that we do` `                ``# not increment i here` `            `  `            ``else` `:`   `                ``# if (len == 0)` `                ``lps[i] ``=` `0` `                ``i ``=` `i ``+` `1` ` `  `    ``res ``=` `lps[n``-``1``]` ` `  `    ``# Since we are looking for` `    ``# non overlapping parts.` `    ``return` `res;` `        `  ` `  `# Driver program to test above function` `s ``=` `"bbabbabb"` `print``(longestPrefixSuffix(s))`     `# This code is contributed` `# by Nikita Tiwari.` `#Corrected by Nilanshu Yadav`

## C#

 `// Efficient C# program to find length of ` `// the longest prefix which is also suffix` `using` `System;`   `class` `GFG {` `    `  `    ``// Returns length of the longest prefix` `    ``// which is also suffix and the two do` `    ``// not overlap. This function mainly is` `    ``// copy computeLPSArray() of in below post` `    ``// https://www.geeksforgeeks.org/searching-` `    ``// for-patterns-set-2-kmp-algorithm/` `    ``static` `int` `longestPrefixSuffix(``string` `s)` `    ``{` `        ``int` `n = s.Length;` `    `  `        ``int` `[]lps = ``new` `int``[n];` `        `  `        ``// lps[0] is always 0` `        ``lps[0] = 0; ` `    `  `        ``// length of the previous` `        ``// longest prefix suffix` `        ``int` `len = 0;` `    `  `        ``// the loop calculates lps[i]` `        ``// for i = 1 to n-1` `        ``int` `i = 1;` `        ``while` `(i < n)` `        ``{` `            ``if` `(s[i] == s[len])` `            ``{` `                ``len++;` `                ``lps[i] = len;` `                ``i++;` `            ``}` `            `  `            ``// (pat[i] != pat[len])` `            ``else` `            ``{` `                `  `                ``// This is tricky. Consider` `                ``// the example. AAACAAAA` `                ``// and i = 7. The idea is` `                ``// similar to search step.` `                ``if` `(len != 0)` `                ``{` `                    ``len = lps[len-1];` `    `  `                    ``// Also, note that we do` `                    ``// not increment i here` `                ``}` `                `  `                ``// if (len == 0)` `                ``else` `                ``{` `                    ``lps[i] = 0;` `                    ``i++;` `                ``}` `            ``}` `        ``}` `    `  `        ``int` `res = lps[n-1];` `    `  `        ``// Since we are looking for` `        ``// non overlapping parts.` `        ``return` `(res > n/2) ? n/2 : res;` `    ``}` `    `  `    ``// Driver program ` `    ``public` `static` `void` `Main () ` `    ``{` `        ``string` `s = ``"abcab"``;` `        `  `        ``Console.WriteLine(longestPrefixSuffix(s));` `    ``}` `}`   `// This code is contributed by vt_m.`

## PHP

 ` ``\$n``/2)? ``\$n``/2 : ``\$res``;` `}`   `    ``// Driver Code` `    ``\$s` `= ``"abcab"``;` `    ``echo` `longestPrefixSuffix(``\$s``);`   `// This code is contributed by nitin mittal` `?>`

## Javascript

 ``

Output:

`2`

Time Complexity: O(n)
Auxiliary Space: O(n)

Please refer computeLPSArray() of KMP search for an explanation.

Solution using RegEx:

## Python3

 `# Python code to find length of the longest` `# prefix which is also suffix` `import` `re`   `s ``=` `"ABCABCABCABCABC"` `# Example input`   `print``(``len``(re.findall(r``'^(\w*).*\1\$'``,s)[``0``]))`

## Javascript

 `const s = ``"ABCABCABCABCABC"``; ``// Example input`   `const regex = ``new` `RegExp(`^(\\w*).*\\1\$`);` `const match = s.match(regex);`   `console.log(match[1].length);`   `// THIS CODE IS CONTRIBUTED BY CHANDAN AGARWAL`

## Java

 `import` `java.util.regex.Matcher;` `import` `java.util.regex.Pattern;`   `public` `class` `GFG {` `  ``public` `static` `void` `main(String[] args) {` `    ``String s = ``"ABCABCABCABCABC"``; ``// Example input`   `    ``String regex = ``"^(\\w*).*\\1\$"``;` `    ``Pattern pattern = Pattern.compile(regex);` `    ``Matcher matcher = pattern.matcher(s);`   `    ``if` `(matcher.find()) {` `      ``System.out.println(matcher.group(``1``).length());` `    ``}` `  ``}` `}`

Output:

`6`

Efficient Solution: The idea is to traverse the suffix in reverse order and try to find a match in first half of the string (possible prefix). Here we take advantage of the property of a prefix substring – when traversed in reverse order, the prefix substring’s last character will always terminate at the string’s beginning.

Please note that we search for the prefix in the first half of the string alone because of the constraint given in the problem that the prefix and suffix are non-overlapping.

Algorithm :

1. Maintain two pointers –  one which starts at the end of string(for suffix) and one which starts at the middle of string(for prefix)

2. Keep on decrementing both the pointers provided they match and the prefix pointer is not exhausted( >0) .

3. When a mismatch occurs, reset the suffix pointer back to end of string and repeat step 2.

4. When prefix pointer reaches ‘-1’ (i.e. string is exhausted) the longest common suffix/prefix will be the substring from suffix pointer

to end of the string.  Return the length of this substring.

Implementation:

## Python3

 `# Python3 program to find length` `# of the longest prefix which` `# is also suffix`   `# Returns length of the longest prefix` `# which is also suffix and the two do` `# not overlap.` `def` `longestPrefixSuffix(s):`   `    ``n ``=` `len``(s)`   `    ``if` `n ``=``=` `0``:` `        ``return` `0`   `    ``# end_suffix and end_prefix are used to keep track of the common suffix and prefix respectively.` `    ``# For the prefix we search only in first half of string (0-->n//2-1) since` `    ``# suffix and prefix do not overlap.` `    ``end_suffix ``=` `n``-``1` `    ``end_prefix ``=` `n ``/``/` `2` `-` `1`   `    ``# Traverse each character of suffix from end to start and check for a match of prefix` `    ``# in first half of array.` `    ``while` `end_prefix >``=` `0``:` `        ``if` `s[end_prefix] !``=` `s[end_suffix]:` `            ``if` `end_suffix !``=` `n``-``1``:` `                ``end_suffix ``=` `n``-``1`  `# reset end_suffix` `            ``else``:` `                ``end_prefix ``-``=` `1` `        ``else``:` `            ``end_suffix ``-``=` `1` `            ``end_prefix ``-``=` `1`   `    ``# The longest common suffix and prefix is s[end+1:]` `    ``return` `n``-``end_suffix``-``1`     `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    ``s ``=` `"ABCABCABCABCABC"` `    ``print``(longestPrefixSuffix(s))`   `# This code is contributed by Reshma Koshy.`

## Javascript

 `// JavaScript program to find length` `// of the longest prefix which` `// is also suffix`   `// Returns length of the longest prefix` `// which is also suffix and the two do` `// not overlap.` `function` `longestPrefixSuffix(s) {`   `    ``let n = s.length;` `    `  `    ``if` `(n === 0) {` `        ``return` `0;` `    ``}` `    `  `    ``// end_suffix and end_prefix are used to keep track of the common suffix and prefix respectively.` `    ``// For the prefix we search only in first half of string (0-->n//2-1) since` `    ``// suffix and prefix do not overlap.` `    ``let end_suffix = n - 1;` `    ``let end_prefix = Math.floor(n / 2) - 1;` `    `  `    ``// Traverse each character of suffix from end to start and check for a match of prefix` `    ``// in first half of array.` `    ``while` `(end_prefix >= 0) {` `        ``if` `(s[end_prefix] !== s[end_suffix]) {` `            ``if` `(end_suffix !== n - 1) {` `                ``end_suffix = n - 1; ``// reset end_suffix` `            ``} ``else` `{` `                ``end_prefix -= 1;` `            ``}` `        ``} ``else` `{` `            ``end_suffix -= 1;` `            ``end_prefix -= 1;` `        ``}` `    ``}`   `    ``// The longest common suffix and prefix is s[end+1:]` `    ``return` `n - end_suffix - 1;` `}`   `// Driver Code` `let s = ``"ABCABCABCABCABC"``;` `console.log(longestPrefixSuffix(s));`

Output

`6`

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

My Personal Notes arrow_drop_up
Related Articles