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

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:
e
ek
k
“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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 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); ` ` `  `    ``// 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; ` `    ``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 */`

Output:

```e
ek
k
```

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 Striver(underscore)79 at Codechef and codeforces D

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.

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.