Skip to content
Related Articles
Open in App
Not now

Related Articles

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

Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 01 Nov, 2022
Improve Article
Save Article

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”

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.
  • Print the answer.

C++




// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// KMP algorithm
int* kmp(string& s)
{
 
    int n = s.size();
    int* lps = new int[n];
 
    lps[0] = 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] = 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


Javascript




<script>
// JavaScript Program to implement
// the above approach
 
// KMP algorithm
function kmp(s)
{
 
    var n = s.length;
    var lps = new Array(n);
 
    lps[0] = 0;
    var i = 1;
    var 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
function findString(s, k)
{
 
    var n = s.length;
 
    // Finding the longest proper prefix
    // which is also suffix
    var lps = kmp(s);
 
    // ans string
    var ans = "";
 
    var suff = s.substr(0, n - lps[n - 1]);
 
    for (var 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
var k = 3;
 
var s = "geeksforgeeks";
 
document.write(findString(s, k));
 
//This code is contributed by phasing17
</script>


Output

geeksforgeeksforgeeksforgeeks

 Time Complexity: O( |S| ), where S is the given string
Auxiliary Space: O( |S| )


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!