# Smallest String consisting of a String S exactly K times as a Substring

Given a string S of length N and integer K, find the smallest length string which contains the string S as a sub string exactly K times.

Examples:

Input: S = “abba”, K = 3
Output: abbabbabba
Explanation: The string “abba” occurs K times in the string abbabbabba, i.e. {abbabbabba, abbabbabba, abbabbabba}

Input: S = “geeksforgeeks”, K = 3
Output: “geeksforgeeksforgeeksforgeeks”

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: To optimize the above approach, find the Longest Proper Prefix which is also a suffix for the given string S, and then generate a substring of S excluding the longest common prefix and add this substring to the answer exactly K – 1 times to the original string. Follow the below steps to solve the problem:

• Find the length of the longest proper prefix using KMP algorithm.
• Append substring S.substring(N-lps[N-1]) to S, exactly K-1 times.
• Below is the implementation of the above approach.

## C++

 `// C++ Program to implement  ` `// the above approach  ` `#include   ` `using` `namespace` `std;  ` ` `  `// KMP algorithm  ` `int``* kmp(string& s)  ` `{  ` ` `  `    ``int` `n = s.size();  ` `    ``int``* lps = ``new` `int``[n];  ` ` `  `    ``lps = 0;  ` `    ``int` `i = 1, len = 0;  ` `    ``while` `(i < n) {  ` ` `  `        ``if` `(s[i] == s[len]) {  ` `            ``len++;  ` `            ``lps[i] = len;  ` `            ``i++;  ` `        ``}  ` `        ``else` `{  ` `            ``if` `(len != 0) {  ` `                ``len = lps[len - 1];  ` `            ``}  ` `            ``else` `{  ` `                ``lps[i] = 0;  ` `                ``i++;  ` `            ``}  ` `        ``}  ` `    ``}  ` ` `  `    ``return` `lps;  ` `}  ` ` `  `// Function to return the required string  ` `string findString(string& s, ``int` `k)  ` `{  ` ` `  `    ``int` `n = s.length();  ` ` `  `    ``// Finding the longest proper prefix  ` `    ``// which is also suffix  ` `    ``int``* lps = kmp(s);  ` ` `  `    ``// ans string  ` `    ``string ans = ``""``;  ` ` `  `    ``string suff  ` `        ``= s.substr(0, n - lps[n - 1]);  ` ` `  `    ``for` `(``int` `i = 0; i < k - 1; ++i) {  ` ` `  `        ``// Update ans appending the  ` `        ``// substring K - 1 times  ` `        ``ans += suff;  ` `    ``}  ` ` `  `    ``// Append the original string  ` `    ``ans += s;  ` ` `  `    ``// Returning min length string  ` `    ``// which contain exactly k  ` `    ``// substring of given string  ` `    ``return` `ans;  ` `}  ` ` `  `// Driver Code  ` `int` `main()  ` `{  ` ` `  `    ``int` `k = 3;  ` ` `  `    ``string s = ``"geeksforgeeks"``;  ` ` `  `    ``cout << findString(s, k) << endl;  ` `}  `

## Java

 `// Java program to implement  ` `// the above approach  ` `import` `java.util.*; ` ` `  `class` `GFG{ ` `     `  `// KMP algorithm  ` `static` `int``[] kmp(String s)  ` `{  ` `    ``int` `n = s.length();  ` `    ``int``[] lps = ``new` `int``[n];  ` `    ``lps[``0``] = ``0``;  ` ` `  `    ``int` `i = ``1``, len = ``0``;  ` `     `  `    ``while` `(i < n) ` `    ``{ ` `        ``if` `(s.charAt(i) == s.charAt(len)) ` `        ``{  ` `            ``len++;  ` `            ``lps[i] = len;  ` `            ``i++;  ` `        ``}  ` `        ``else`  `        ``{  ` `            ``if` `(len != ``0``) ` `            ``{  ` `                ``len = lps[len - ``1``];  ` `            ``}  ` `            ``else` `            ``{  ` `                ``lps[i] = ``0``;  ` `                ``i++;  ` `            ``}  ` `        ``}  ` `    ``}  ` `    ``return` `lps;  ` `}  ` ` `  `// Function to return the required string  ` `static` `String findString(String s, ``int` `k)  ` `{  ` `    ``int` `n = s.length();  ` ` `  `    ``// Finding the longest proper prefix  ` `    ``// which is also suffix  ` `    ``int``[] lps = kmp(s);  ` ` `  `    ``// ans string  ` `    ``String ans = ``""``;  ` ` `  `    ``String suff    = s.substring(``0``, n - lps[n - ``1``]);  ` ` `  `    ``for``(``int` `i = ``0``; i < k - ``1``; ++i)  ` `    ``{  ` `         `  `        ``// Update ans appending the  ` `        ``// substring K - 1 times  ` `        ``ans += suff;  ` `    ``}  ` ` `  `    ``// Append the original string  ` `    ``ans += s;  ` ` `  `    ``// Returning min length string  ` `    ``// which contain exactly k  ` `    ``// substring of given string  ` `    ``return` `ans;  ` `} ` ` `  `// Driver code ` `public` `static` `void` `main (String[] args)  ` `{ ` `    ``int` `k = ``3``;  ` `     `  `    ``String s = ``"geeksforgeeks"``;  ` `     `  `    ``System.out.println(findString(s, k));  ` `} ` `} ` ` `  `// This code is contributed by offbeat `

## Python3

 `# Python3 program to implement  ` `# the above approach  ` ` `  `# KMP algorithm  ` `def` `kmp(s):  ` `     `  `    ``n ``=` `len``(s)  ` `    ``lps ``=` `[``None``] ``*` `n  ` `    ``lps[``0``] ``=` `0` ` `  `    ``i, ``Len` `=` `1``, ``0` `     `  `    ``while` `(i < n): ` `     `  `        ``if` `(s[i] ``=``=` `s[``Len``]): ` `            ``Len` `+``=` `1` `            ``lps[i] ``=` `Len` `            ``i ``+``=` `1` `             `  `        ``else``: ` `            ``if` `(``Len` `!``=` `0``):  ` `                ``Len` `=` `lps[``Len` `-` `1``] ` `            ``else``: ` `                ``lps[i] ``=` `0` `                ``i ``+``=` `1` `                 `  `    ``return` `lps ` `     `  `# Function to return the required string  ` `def` `findString(s, k):  ` ` `  `    ``n ``=` `len``(s)  ` ` `  `    ``# Finding the longest proper prefix  ` `    ``# which is also suffix  ` `    ``lps ``=` `kmp(s)  ` ` `  `    ``# ans string  ` `    ``ans ``=` `""  ` `     `  `    ``suff ``=` `s[``0``: n ``-` `lps[n ``-` `1``] : ``1``] ` ` `  `    ``for` `i ``in` `range``(k ``-` `1``):  ` `         `  `        ``# Update ans appending the  ` `        ``# substring K - 1 times  ` `        ``ans ``+``=` `suff ` ` `  `    ``# Append the original string  ` `    ``ans ``+``=` `s ` ` `  `    ``# Returning min length string  ` `    ``# which contain exactly k  ` `    ``# substring of given string  ` `    ``return` `ans ` ` `  `# Driver code ` `k ``=` `3` `     `  `s ``=` `"geeksforgeeks"` `     `  `print``(findString(s, k))  ` ` `  `# This code is contributed by divyeshrabadiya07  `

## C#

 `// C# program to implement  ` `// the above approach  ` `using` `System; ` ` `  `class` `GFG{ ` `     `  `// KMP algorithm  ` `static` `int``[] kmp(``string` `s)  ` `{  ` `    ``int` `n = s.Length;  ` `    ``int``[] lps = ``new` `int``[n];  ` `    ``lps = 0;  ` ` `  `    ``int` `i = 1, len = 0;  ` `     `  `    ``while` `(i < n) ` `    ``{ ` `        ``if` `(s[i] == s[len]) ` `        ``{  ` `            ``len++;  ` `            ``lps[i] = len;  ` `            ``i++;  ` `        ``}  ` `        ``else` `        ``{  ` `            ``if` `(len != 0) ` `            ``{  ` `                ``len = lps[len - 1];  ` `            ``}  ` `            ``else` `            ``{  ` `                ``lps[i] = 0;  ` `                ``i++;  ` `            ``}  ` `        ``}  ` `    ``}  ` `    ``return` `lps;  ` `}  ` ` `  `// Function to return the required string  ` `static` `string` `findString(``string` `s, ``int` `k)  ` `{  ` `    ``int` `n = s.Length;  ` ` `  `    ``// Finding the longest proper prefix  ` `    ``// which is also suffix  ` `    ``int``[] lps = kmp(s);  ` ` `  `    ``// ans string  ` `    ``string` `ans = ``""``;  ` ` `  `    ``string` `suff = s.Substring(0,  ` `                              ``n - lps[n - 1]);  ` ` `  `    ``for``(``int` `i = 0; i < k - 1; ++i)  ` `    ``{  ` `         `  `        ``// Update ans appending the  ` `        ``// substring K - 1 times  ` `        ``ans += suff;  ` `    ``}  ` ` `  `    ``// Append the original string  ` `    ``ans += s;  ` ` `  `    ``// Returning min length string  ` `    ``// which contain exactly k  ` `    ``// substring of given string  ` `    ``return` `ans;  ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main (``string``[] args)  ` `{ ` `    ``int` `k = 3;  ` `     `  `    ``string` `s = ``"geeksforgeeks"``;  ` `     `  `    ``Console.Write(findString(s, k));  ` `} ` `} ` ` `  `// This code is contributed by rutvik_56 `

Output:

```geeksforgeeksforgeeksforgeeks
```

Time Complexity: O(N*K )
Auxiliary Space: O(K* N)

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.

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.

2

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