Lexicographical concatenation of all substrings of a string

Given a string, find the concatenation of all substrings in lexicographic order.

Examples:

Input : s = "abc"
Output : aababcbbcc
The substrings of s in lexicographic order are "a", "b", "c", "ab", "abc", "bc". Concatenation of substrings is "a"+"ab"+"abc"+"b"+"bc"+"c" = "aababcbbcc".
Input : s = "cba"
Output : abbaccbcba

1. Find all the substrings of string and store it in a string array. The size of array would be n*(n+1)/2 where n is length of input string.
2. Sort the string array to make them all in lexicographical order.
3. Concatenate the strings of string array in another empty string.

Implementation:

// CPP Program to create concatenation of all
// substrings in lexicographic order.
#include <bits/stdc++.h>
using namespace std;

string lexicographicSubConcat(string s)
{
    int n = s.length();

    // Creating an array to store substrings
    int sub_count = n*(n+1)/2;
    string arr[sub_count];     

    // finding all substrings of string
    int index = 0;
    for (int i = 0; i < n; i++) 
        for (int len = 1; len <= n - i; len++) 
            arr[index++] = s.substr(i, len);
    
    // Sort all substrings in lexicographic
    // order
    sort(arr, arr + sub_count); 

    // Concatenating all substrings
    string res = "";
    for (int i = 0; i < sub_count; i++) 
        res += arr[i];     
        
    return res;    
}

int main()
{
    string s = "abc"; 
    cout << lexicographicSubConcat(s);
    return 0;
} 

// Java Program to create concatenation of all
// substrings in lexicographic order.
import java.util.*;

class GFG 
{
    

static String lexicographicSubConcat(String s)
{
    int n = s.length();

    // Creating an array to store substrings
    int sub_count = n*(n+1)/2;
    String []arr = new String[sub_count];     

    // finding all substrings of string
    int index = 0;
    for (int i = 0; i < n; i++) 
        for (int len = 1; len <= n - i; len++) 
        {
                arr[index++] = s.substring(i, i+len);
        }
    // Sort all substrings in lexicographic
    // order
    Arrays.sort(arr); 

    // Concatenating all substrings
    String res = "";
    for (int i = 0; i < sub_count; i++) 
        res += arr[i];     
        
    return res; 
}

// Driver code
public static void main(String[] args) 
{
    String s = "abc"; 
    System.out.println(lexicographicSubConcat(s));
}
}

// This code has been contributed by 29AjayKumar

# Python Program to create concatenation of all
# substrings in lexicographic order.

def lexicographicSubConcat(s):
    n = len(s);

    # Creating an array to store substrings
    sub_count = (n * (n + 1))//2;
    arr = [0]*sub_count;     

    # finding all substrings of string
    index = 0;
    for i in range(n):
        for j in range(1,n - i + 1):
            arr[index] = s[i:i + j];
            index += 1;
    
    # Sort all substrings in lexicographic
    # order
    arr.sort(); 

    # Concatenating all substrings
    res = "";
    for i in range(sub_count):
        res += arr[i];     
        
    return res; 

s = "abc"; 
print(lexicographicSubConcat(s));

# This code is contributed by Princi Singh

// C# Program to create concatenation of all
// substrings in lexicographic order.
using System;     
    
class GFG 
{
    
static String lexicographicSubConcat(String s)
{
    int n = s.Length;

    // Creating an array to store substrings
    int sub_count = n*(n+1)/2;
    String []arr = new String[sub_count];     

    // finding all substrings of string
    int index = 0;
    for (int i = 0; i < n; i++) 
        for (int len = 1; len <= n - i; len++) 
        {
            arr[index++] = s.Substring(i, len);
        }
        
    // Sort all substrings in lexicographic
    // order
    Array.Sort(arr); 

    // Concatenating all substrings
    String res = "";
    for (int i = 0; i < sub_count; i++) 
        res += arr[i];     
        
    return res; 
}

// Driver code
public static void Main(String[] args) 
{
    String s = "abc"; 
    Console.WriteLine(lexicographicSubConcat(s));
}
}

/* This code contributed by PrinciRaj1992 */

<script>

// Javascript Program to create concatenation of all
// substrings in lexicographic order.

function lexicographicSubConcat(s)
{
    var n = s.length;

    // Creating an array to store substrings
    var sub_count = n*parseInt((n+1)/2);
    var arr = Array(sub_count);     

    // finding all substrings of string
    var index = 0;
    for (var i = 0; i < n; i++) 
        for (var len = 1; len <= n - i; len++) 
            arr[index++] = s.substring(i,i+ len);
    
    // Sort all substrings in lexicographic
    // order
    arr.sort();

    // Concatenating all substrings
    var res = "";
    for (var i = 0; i < sub_count; i++) 
        res += arr[i];     
        
    return res;    
}

var s = "abc"; 
document.write( lexicographicSubConcat(s));

</script> 

aababcbbcc

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

Optimized Lexicographical Substring Concatenation Using Suffix Array and Sorting

This approach optimizes the concatenation of all substrings in lexicographical order by using a suffix array combined with a direct sorting method. Rather than explicitly generating all substrings and then sorting them, we utilize the properties of a suffix array to manage and sort the substrings indirectly. This technique leverages the suffix array's inherent ability to organize substrings efficiently, reducing both the time and space complexities associated with direct substring management and sorting.

• Suffix Array Construction: Build a list of starting indices for all suffixes of the string.
• Sort by Substring: Sort the suffix array based on the lexicographical order of substrings starting at each index.
• Direct Concatenation: Concatenate substrings directly by traversing through the sorted suffix array, extracting and appending substrings from the main string.
• Efficiency: This method avoids the overhead of storing all possible substrings explicitly, thereby saving significant space and potentially reducing sorting time.

Below is the implementation of above approach:

#include <algorithm>
#include <iostream>
#include <vector>

// Function to compare suffixes based on the substrings they
// represent
bool compareSuffix(const std::string& s, int i, int j)
{
    return s.substr(i) < s.substr(j);
}

// Function to concatenate lexicographically sorted
// substrings of a string
std::string
lexicographicSubConcatOptimized(const std::string& s)
{
    int n = s.length();

    // Generate suffix indices
    std::vector<int> suffix_indices(n);
    for (int i = 0; i < n; ++i) {
        suffix_indices[i] = i;
    }

    // Sort suffix indices based on the substrings they
    // represent
    std::sort(suffix_indices.begin(), suffix_indices.end(),
              [&](int i, int j) {
                  return compareSuffix(s, i, j);
              });

    // Concatenate all substrings in sorted order by
    // expanding each suffix to the end of the string
    std::string result;
    for (int start : suffix_indices) {
        for (int length = 1; length <= n - start;
             ++length) {
            result += s.substr(start, length);
        }
    }

    return result;
}

int main()
{
    // Example usage
    std::string s = "bca";
    std::cout << lexicographicSubConcatOptimized(s)
              << std::endl;

    return 0;
}

import java.util.Arrays;

public class Main {

    static String lexicographicSubConcatOptimized(String s)
    {
        int n = s.length();

        // Generate suffix indices
        Integer[] suffixIndices = new Integer[n];
        for (int i = 0; i < n; i++) {
            suffixIndices[i] = i;
        }

        // Sort suffix indices based on the substrings they
        // represent
        Arrays.sort(suffixIndices,
                    (a, b)
                        -> s.substring(a).compareTo(
                            s.substring(b)));

        // Concatenate all substrings in sorted order by
        // expanding each suffix to the end of the string
        StringBuilder result = new StringBuilder();
        for (int start : suffixIndices) {
            for (int length = 1; length <= n - start;
                 length++) {
                result.append(
                    s.substring(start, start + length));
            }
        }

        return result.toString();
    }

    // Example usage
    public static void main(String[] args)
    {
        String s = "bca";
        System.out.println(
            lexicographicSubConcatOptimized(s));
    }
}

def lexicographicSubConcatOptimized(s):
    n = len(s)

    # Generate suffix indices
    suffix_indices = list(range(n))

    # Sort suffix indices based on the substrings they represent
    suffix_indices.sort(key=lambda x: s[x:])

    # Concatenate all substrings in sorted order by expanding each suffix to the end of the string
    result = ""
    for start in suffix_indices:
        for length in range(1, n - start + 1):
            result += s[start:start + length]

    return result


# Example usage
s = "bca"
print(lexicographicSubConcatOptimized(s))

function lexicographicSubConcatOptimized(s) {
    let n = s.length;

    // Generate suffix indices
    let suffixIndices = Array.from({ length: n }, (_, i) => i);

    // Sort suffix indices based on the substrings they represent
    suffixIndices.sort((a, b) => s.substring(a).localeCompare(s.substring(b)));

    // Concatenate all substrings in sorted order by expanding each suffix to the end of the string
    let result = "";
    for (let start of suffixIndices) {
        for (let length = 1; length <= n - start; length++) {
            result += s.substring(start, start + length);
        }
    }

    return result;
}

// Example usage
let s = "bca";
console.log(lexicographicSubConcatOptimized(s));

aababcbbcc

Time Complexity: O(n^2 log n). This comes from sorting the suffixes which takes O(n log n) and the subsequent substring extraction and concatenation. Although each suffix can potentially contribute up to n characters, the actual substring operations (contribution to the final string) are bounded by the quadratic term.

Auxiliary Space: O(n). The primary space consumption comes from storing the suffix indices and the output string. The intermediate storage does not exceed the size of the original string significantly, as no extra structures are used for all possible substrings. This is a marked improvement over the original approach.