🔴 Live TV: dsa/print kth character sorted concatenated substrings string

Given a string s consisting of lowercase alphabetic characters, consider all unique substrings of s (i.e., no substring value is repeated, even if it occurs at multiple positions in s). Arrange these unique substrings in lexicographically sorted order, then concatenate them into a single string.

Find the k-th character (1-indexed) of this concatenated string.

Examples:

Input: s = "banana", k = 10
Output: n
Explanation: The unique substrings of "banana", sorted lexicographically, are:
a, an, ana, anan, anana, b, ba, ban, bana, banan, banana, n, na, nan, nana
Concatenating them gives:
"a" + "an" + "ana" + "anan" + "anana" + "b" + "ba" + "ban" + "bana" + "banan" + "banana" + "n" + "na" + "nan" + "nana"
Tracking cumulative length as we concatenate:
"a" -> length 1 (cumulative: 1)
"an" -> length 2 (cumulative: 3)
"ana" -> length 3 (cumulative: 6)
"anan" -> length 4 (cumulative: 10)
The 10th character falls at the end of "anan", which is 'n'.
Hence, the answer is 'n'.

Input: s = "abcdefg", k = 10
Output: d
Explanation: Since all characters in "abcdefg" are distinct, every substring is already unique.
Sorted lexicographically, the substrings starting with 'a' come first:
a, ab, abc, abcd, abcde, abcdef, abcdefg, ...
Tracking cumulative length as we concatenate:
"a" -> length 1 (cumulative: 1)
"ab" -> length 2 (cumulative: 3)
"abc" -> length 3 (cumulative: 6)
"abcd" -> length 4 (cumulative: 10)
The 10th character falls at the end of "abcd", which is 'd'.
Hence, the answer is 'd'.

Try It Yourself

Table of Content

[Naive Approach] Generate All Unique Substrings and Sort - O(n ^ 3 log n) Time and O(n ^ 3) Space
[Expected Approach] Using Suffix Array and LCP Array - O(n log ^ 2 n) Time and O(n) Space

[Naive Approach] Generate All Unique Substrings and Sort - O(n ^ 3 log n) Time and O(n ^ 3) Space

The idea is to generate all substrings, store only unique ones in a set, sort them lexicographically, and traverse them while counting characters until the k-th character is reached.

Working of Approach:

Generate all possible substrings of the given string and insert them into a set to keep only unique substrings while maintaining lexicographical order.
Traverse the substrings stored in the set one by one.
Keep a running count of the total number of characters contributed by the processed substrings.
When the cumulative count reaches or exceeds k, the required character lies in the current substring.
Return the corresponding character using its position within the current substring.

C++

#include <bits/stdc++.h>
using namespace std;

char findKthChar(string &s, int k)
{
    set<string> st;
    int n = s.size();

    // Generate all substrings.
    for (int i = 0; i < n; i++)
    {
        string cur = "";
        for (int j = i; j < n; j++)
        {
            cur += s[j];
            st.insert(cur);
        }
    }

    // Traverse unique substrings in sorted order.
    int cnt = 0;
    for (auto &str : st)
    {
        if (cnt + str.size() >= k)
            return str[k - cnt - 1];
        cnt += str.size();
    }

    return '#';
}

int main()
{
    string s = "abcdefg";
    int k = 10;

    cout << findKthChar(s, k);

    return 0;
}

Java

import java.util.HashSet;
import java.util.Set;

public class GFG {

    public static char findKthChar(String s, int k)
    {
        Set<String> st = new HashSet<>();
        int n = s.length();

        // Generate all substrings.
        for (int i = 0; i < n; i++) {
            String cur = "";
            for (int j = i; j < n; j++) {
                cur += s.charAt(j);
                st.add(cur);
            }
        }

        // Traverse unique substrings in sorted order.
        int cnt = 0;
        String[] sortedStrings = st.toArray(new String[0]);
        java.util.Arrays.sort(sortedStrings);
        for (String str : sortedStrings) {
            if (cnt + str.length() >= k)
                return str.charAt(k - cnt - 1);
            cnt += str.length();
        }

        return '#';
    }

    public static void main(String[] args)
    {
        String s = "abcdefg";
        int k = 10;

        System.out.println(findKthChar(s, k));
    }
}

Python

def findKthChar(s, k):
    st = set()
    n = len(s)

    # Generate all substrings.
    for i in range(n):
        cur = ""
        for j in range(i, n):
            cur += s[j]
            st.add(cur)

    # Traverse unique substrings in sorted order.
    cnt = 0
    sorted_strings = sorted(st)
    for str_ in sorted_strings:
        if cnt + len(str_) >= k:
            return str_[k - cnt - 1]
        cnt += len(str_)

    return '#'


if __name__ == "__main__":
    s = "abcdefg"
    k = 10

    print(findKthChar(s, k))

using System;
using System.Collections.Generic;

class Program {
    static char findKthChar(string s, int k)
    {
        HashSet<string> st = new HashSet<string>();
        int n = s.Length;

        // Generate all substrings.
        for (int i = 0; i < n; i++) {
            string cur = "";
            for (int j = i; j < n; j++) {
                cur += s[j];
                st.Add(cur);
            }
        }

        // Traverse unique substrings in sorted order.
        List<string> sortedStrings = new List<string>(st);
        sortedStrings.Sort();

        int cnt = 0;
        foreach(string str in sortedStrings)
        {
            if (cnt + str.Length >= k)
                return str[k - cnt - 1];

            cnt += str.Length;
        }

        return '#';
    }

    static void Main()
    {
        string s = "abcdefg";
        int k = 10;

        Console.WriteLine(findKthChar(s, k));
    }
}

JavaScript

function findKthChar(s, k)
{
    const st = new Set();
    const n = s.length;

    // Generate all substrings.
    for (let i = 0; i < n; i++) {
        let cur = "";
        for (let j = i; j < n; j++) {
            cur += s[j];
            st.add(cur);
        }
    }

    // Traverse unique substrings in sorted order.
    let cnt = 0;
    const sortedStrings = Array.from(st).sort();
    for (const str of sortedStrings) {
        if (cnt + str.length >= k)
            return str[k - cnt - 1];
        cnt += str.length;
    }

    return "#";
}

// Driver Code
const s = "abcdefg";
const k = 10;
console.log(findKthChar(s, k));

Output

[Expected Approach] Using Suffix Array and LCP Array - O(n log ^ 2 n) Time and O(n) Space

The idea is to process suffixes in lexicographical order using a suffix array. The LCP array tells how many prefixes are already counted, so only new prefixes contribute unique substrings. Count their contribution without generating substrings and locate the required character using binary search.