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”

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.
  • Below is the implementation of the above approach.

    C++

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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; 

    chevron_right

    
    

    Java

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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

    chevron_right

    
    

    Python3

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    # Python3 program to implement 
    # the above approach 
      
    # KMP algorithm 
    def kmp(s): 
          
        n = len(s) 
        lps = [None] *
        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 

    chevron_right

    
    

    C#

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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

    chevron_right

    
    

    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

    Recommended Posts:


    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.