# Queries to answer the X-th smallest sub-string lexicographically

• Difficulty Level : Basic
• Last Updated : 22 Jun, 2022

Given a string str and Q queries. Every query consists of a number X, the task is to print the Xth lexicographically smallest sub-string of the given string str

Examples:

Input: str = “geek”, q[] = {1, 5, 10}
Output:

ek

“e”, “e”, “ee”, “eek”, “ek”, “g”, “ge”, “gee”, “geek” and “k” are
all the possible sub-strings in lexicographically sorted order.

Input: str = “abcgdhge”, q[] = {15, 32}
Output:
bcgdhge
gdhge

Approach: Generate all the sub-strings and store them in any data structure and sort that data structure lexicographically. In the solution below, we have used a vector to store all the sub-strings and the inbuilt sort function sorts them in the given order. Now, for every query print vec[X – 1], which will be the Xth smallest sub-string.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach` `#include ` `using` `namespace` `std;`   `// Function to pre-process the sub-strings` `// in sorted order` `void` `pre_process(vector& substrings, string s)` `{` `    ``int` `n = s.size();`   `    ``// Generate all substrings` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``string dup = ``""``;`   `        ``// Iterate to find all sub-strings` `        ``for` `(``int` `j = i; j < n; j++) {` `            ``dup += s[j];`   `            ``// Store the sub-string in the vector` `            ``substrings.push_back(dup);` `        ``}` `    ``}`   `    ``// Sort the substrings lexicographically` `    ``sort(substrings.begin(), substrings.end());` `}`   `// Driver code` `int` `main()` `{` `    ``string s = ``"geek"``;`   `    ``// To store all the sub-strings` `    ``vector substrings;` `    ``pre_process(substrings, s);`   `    ``int` `queries[] = { 1, 5, 10 };` `    ``int` `q = ``sizeof``(queries) / ``sizeof``(queries[0]);`   `    ``// Perform queries` `    ``for` `(``int` `i = 0; i < q; i++)` `        ``cout << substrings[queries[i] - 1] << endl;`   `    ``return` `0;` `}`

## Java

 `// Java implementation of the approach` `import` `java.util.*;`   `class` `GFG` `{`   `// Function to pre-process the sub-strings` `// in sorted order` `static` `void` `pre_process(String substrings[],String s)` `{` `    ``int` `n = s.length();`   `    ``// Generate all substrings` `    ``int` `count = ``0``;` `    ``for` `(``int` `i = ``0``; i < n; i++) ` `    ``{` `        ``String dup = ``""``;`   `        ``// Iterate to find all sub-strings` `        ``for` `(``int` `j = i; j < n; j++) ` `        ``{` `            ``dup += s.charAt(j);`   `            ``// Store the sub-string in the vector` `            ``substrings[count++] = dup;` `        ``}` `    ``}`   `    ``// Sort the substrings lexicographically` `    ``int` `size = substrings.length;`   `    ``for``(``int` `i = ``0``; i < size-``1``; i++) {` `        ``for` `(``int` `j = i + ``1``; j < substrings.length; j++) ` `        ``{` `            ``if``(substrings[i].compareTo(substrings[j]) > ``0``) ` `            ``{` `                ``String temp = substrings[i];` `                ``substrings[i] = substrings[j];` `                ``substrings[j] = temp;` `            ``}` `        ``}` `    `  `    ``//sort(substrings.begin(), substrings.end());` `}` `}`   `// Driver code` `public` `static` `void` `main(String args[])` `{` `    ``String s = ``"geek"``;`   `    ``// To store all the sub-strings` `    ``String substrings[] = ``new` `String[``10``];` `    ``pre_process(substrings, s);`   `    ``int` `queries[] = { ``1``, ``5``, ``10` `};` `    ``int` `q = queries.length;`   `    ``// Perform queries` `    ``for` `(``int` `i = ``0``; i < q; i++)` `        ``System.out.println(substrings[queries[i]-``1``]);`   `}` `}`   `// This code is contributed by` `// Surendra_Gangwar`

## Python3

 `# Python3 implementation of the approach `   `# Function to pre-process the sub-strings ` `# in sorted order ` `def` `pre_process(substrings, s) : ` `    `  `    ``n ``=` `len``(s); `   `    ``# Generate all substrings ` `    ``for` `i ``in` `range``(n) :` `        ``dup ``=` `""; `   `        ``# Iterate to find all sub-strings ` `        ``for` `j ``in` `range``(i,n) : ` `            ``dup ``+``=` `s[j]; `   `            ``# Store the sub-string in the vector ` `            ``substrings.append(dup); `   `    ``# Sort the substrings lexicographically ` `    ``substrings.sort();` `    ``return` `substrings;`     `# Driver code ` `if` `__name__ ``=``=` `"__main__"` `: `   `    ``s ``=` `"geek"``; `   `    ``# To store all the sub-strings ` `    ``substrings ``=` `[]; ` `    ``substrings ``=` `pre_process(substrings, s); `   `    ``queries ``=` `[ ``1``, ``5``, ``10` `]; ` `    ``q ``=` `len``(queries); `   `    ``# Perform queries ` `    ``for` `i ``in` `range``(q) :` `        ``print``(substrings[queries[i] ``-` `1``]); ` `        `  `# This code is contributed by AnkitRai01`

## C#

 `// C# code for above given approach` `using` `System;` `    `  `class` `GFG` `{`   `// Function to pre-process the sub-strings` `// in sorted order` `static` `void` `pre_process(String []substrings,String s)` `{` `    ``int` `n = s.Length;`   `    ``// Generate all substrings` `    ``int` `count = 0;` `    ``for` `(``int` `i = 0; i < n; i++) ` `    ``{` `        ``String dup = ``""``;`   `        ``// Iterate to find all sub-strings` `        ``for` `(``int` `j = i; j < n; j++) ` `        ``{` `            ``dup += s[j];`   `            ``// Store the sub-string in the vector` `            ``substrings[count++] = dup;` `        ``}` `    ``}`   `    ``// Sort the substrings lexicographically` `    ``int` `size = substrings.Length;`   `    ``for``(``int` `i = 0; i < size-1; i++)` `    ``{` `        ``for` `(``int` `j = i + 1; j < substrings.Length; j++) ` `        ``{` `            ``if``(substrings[i].CompareTo(substrings[j]) > 0) ` `            ``{` `                ``String temp = substrings[i];` `                ``substrings[i] = substrings[j];` `                ``substrings[j] = temp;` `            ``}` `        ``}` `    `  `    ``//sort(substrings.begin(), substrings.end());` `}` `}`   `// Driver code` `public` `static` `void` `Main(String []args)` `{` `    ``String s = ``"geek"``;`   `    ``// To store all the sub-strings` `    ``String []substrings = ``new` `String[10];` `    ``pre_process(substrings, s);`   `    ``int` `[]queries = { 1, 5, 10 };` `    ``int` `q = queries.Length;`   `    ``// Perform queries` `    ``for` `(``int` `i = 0; i < q; i++)` `        ``Console.WriteLine(substrings[queries[i]-1]);`   `}` `}`   `/* This code contributed by PrinciRaj1992 */`

## Javascript

 ``

Output:

```e
ek
k```

Time Complexity: O(N2*logN), as we are using an inbuilt sort function to sort an array of size N*N. Where N is the length of the string.

Auxiliary Space: O(N2), as we are using extra space for storing the substrings.

My Personal Notes arrow_drop_up
Recommended Articles
Page :