Open In App

Concatenate suffixes of a String

Given string str the task is to expand the string as follows: 
If the string is abcd, the resultant string will be d, cd, bcd, and abcd in the concatenated form i.e. dcdbcdabcd. We basically need to concatenate all suffixes.

Examples:  

Input: str = “geeks” 
Output: sksekseeksgeeks

Input str = “water” 
Output rerteraterwater 

Simple Approach:  

Below is the implementation of the above approach: 




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to print the expansion of the string
void printExpansion(string str)
{
    int size = 0;
    for (int i = str.length() - 1; i >= 0; i--) {
 
        // Take sub-string from i to n-1
        string subStr = str.substr(i, ++size);
 
        // Print the sub-string
        cout << subStr;
    }
}
 
// Driver code
int main()
{
    string str = "geeks";
    printExpansion(str);
 
    return 0;
}




// Java implementation of the approach
 
public class  GFG {
 
    // Function to print the expansion of the string
    static void printExpansion(String str)
    {
        for (int i = str.length() - 1; i >= 0; i--) {
     
            // Take sub-string from i to n-1
            String subStr = str.substring(i);
     
            // Print the sub-string
            System.out.print(subStr);
 
        }
    }
 
    // Driver code
    public static void main(String args[]) 
    {
        String str = "geeks";
        printExpansion(str);
     
    }
    // This code is contributed by Ryuga
}




# Python3 implementation of the approach
 
# Function to print the expansion of the string
def printExpansion(str):
    for i in range(len(str)-1, -1, -1):
 
        # Take sub-string from i to n-1
        for j in range(i, len(str)):
            print(str[j], end ="")
 
# Driver code
str = "geeks"
printExpansion(str)




// C# implementation of the approach
 using System;
class  GFG {
  
    // Function to print the expansion of the string
    static void printExpansion(String str)
    {
        for (int i = (int)str.Length - 1; i >= 0; i--) {
      
            // Take sub-string from i to n-1
            String subStr = str.Substring(i);
      
            // Print the sub-string
            Console.Write(subStr);
  
        }
    }
  
    // Driver code
    static public void Main(String []args) 
    {
        String str = "geeks";
        printExpansion(str);
      
    }
}
    // This code is contributed by Arnab Kundu




<script>
 
// Javascript implementation of the approach
 
// Function to print the expansion of the string
function printExpansion(str)
{
    var size = 0;
    for (var i = str.length - 1; i >= 0; i--) {
 
        // Take sub-string from i to n-1
        var subStr = str.substring(i, i + ++size);
 
        // Print the sub-string
        document.write( subStr);
    }
}
 
// Driver code
var str = "geeks";
printExpansion(str);
 
</script>

Output
sksekseeksgeeks







Complexity Analysis:

Efficient Approach: 

Maintain a suffix string (which is initially empty). Keep traversing from the end and keep appending the current character.  




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to print the expansion of the string
void printExpansion(string str)
{
    string suff = "";
    for (int i = str.length() - 1; i >= 0; i--) {
 
        // Take sub-string from i to n-1
        suff = suff + str[i];
 
        // Print the sub-string
        cout << suff;
    }
}
 
// Driver code
int main()
{
    string str = "geeks";
    printExpansion(str);
 
    return 0;
}




// Java implementation of the approach
import java.util.*;
 
class solution
{
 
// Function to print the expansion of the string
static void printExpansion(String str)
{
    String suff = "";
    for (int i = str.length() - 1; i >= 0; i--) {
 
        // Take sub-string from i to n-1
        suff = suff + str.charAt(i);
 
        // Print the sub-string
        System.out.print(suff);
    }
}
 
// Driver code
public static void main(String args[])
{
    String str = "geeks";
    printExpansion(str);
 
}
}




# Python3 implementation of the approach
 
# Function to print the expansion
# of the string
def printExpansion( str):
 
    suff = ""
    for i in range (len (str) - 1, -1, -1) :
 
        # Take sub-string from i to n-1
        suff = suff + str[i]
 
        # Print the sub-string
        print (suff, end = "")
 
# Driver code
if __name__ == "__main__":
 
    str = "geeks"
    printExpansion(str)
 
# This code is contributed by ita_c




// C# Implementation of the above approach
using System;
     
class GFG
{
 
// Function to print
// the expansion of the string
static void printExpansion(String str)
{
    String suff = "";
    for (int i = str.Length - 1;
             i >= 0; i--)
    {
 
        // Take sub-string from i to n-1
        suff = suff + str[i];
 
        // Print the sub-string
        Console.Write(suff);
    }
}
 
// Driver code
public static void Main(String []args)
{
    String str = "geeks";
    printExpansion(str);
}
}
 
// This code is contributed by PrinciRaj1992




<script>
 
// Javascript implementation of the approach
 
// Function to print the expansion of the string
function printExpansion(str)
{
    var suff = "";
    for (var i = str.length - 1; i >= 0; i--) {
 
        // Take sub-string from i to n-1
        suff = suff + str[i];
 
        // Print the sub-string
        document.write( suff);
    }
}
 
// Driver code
var str = "geeks";
printExpansion(str);
 
// This code is contributed by rrrtnx.
</script>

Output
sskskeskeeskeeg







Complexity Analysis:

Recursive Approach: 

Steps:

Below is the implementation of the above approach: 




#include <iostream>
#include <string>
 
// Function to expand a string using recursion
std::string ExpandString(const std::string& str)
{
    // Base case
    if (str.length() == 0) {
        return "";
    }
    else {
        // Recursive case
        return ExpandString(str.substr(1)) + str;
    }
}
 
int main()
{
    std::string input_str = "geeks";
    std::string expanded_str = ExpandString(input_str);
    std::cout << expanded_str << std::endl;
    return 0;
}




public class Main {
 
    // Function to expand a string using recursion
    public static String expandString(String str)
    {
        // Base case
        if (str.length() == 0) {
            return "";
        }
        else {
            // Recursive case
            return expandString(str.substring(1)) + str;
        }
    }
 
    public static void main(String[] args)
    {
        String inputStr = "geeks";
        String expandedStr = expandString(inputStr);
        System.out.println(expandedStr);
    }
}
// This code is contributed by shivamgupta0987654321




# Python implementation of the approach
def expand_string(str):
    # Base case
    if len(str) == 0:
        return ""
    else:
        # Recursive case
        return expand_string(str[1:]) + str
 
 
# Driver Code
input_str = "geeks"
expanded_str = expand_string(input_str)
print(expanded_str)




using System;
 
class Program
{
    // Function to expand a string using recursion
    static string ExpandString(string str)
    {
        // Base case
        if (str.Length == 0)
        {
            return "";
        }
        else
        {
            // Recursive case
            return ExpandString(str.Substring(1)) + str;
        }
    }
 
    static void Main()
    {
        string inputStr = "geeks";
        string expandedStr = ExpandString(inputStr);
        Console.WriteLine(expandedStr);
    }
}




function GFG(str) {
    if (str.length === 0) {
        return "";
    } else {
        // Recursive case: call the function with the substring starting from
        // the second character and concatenate the original string at the end
        return GFG(str.substring(1)) + str;
    }
}
 
const inputStr = "geeks";
const expandedStr = GFG(inputStr);
console.log(expandedStr);

Output
sksekseeksgeeks








Time Complexity: O(n^2), where n is the length of the input string str.

Auxiliary Space: O(n^2) 


Article Tags :