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
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++ implementation of the approach #include <bits/stdc++.h> using namespace std;
// Function to pre-process the sub-strings // in sorted order void pre_process(vector<string>& 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<string> 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 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 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# 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 */ |
<script> // Javascript implementation of the approach // Function to pre-process the sub-strings // in sorted order function pre_process(substrings, s)
{ var n = s.length;
// Generate all substrings
for ( var i = 0; i < n; i++) {
var dup = "" ;
// Iterate to find all sub-strings
for ( var j = i; j < n; j++) {
dup += s[j];
// Store the sub-string in the vector
substrings.push(dup);
}
}
// Sort the substrings lexicographically
substrings.sort();
} // Driver code var s = "geek" ;
// To store all the sub-strings var substrings = [];
pre_process(substrings, s); var queries = [1, 5, 10];
var q = queries.length;
// Perform queries for ( var i = 0; i < q; i++)
document.write( substrings[queries[i] - 1] + "<br>" );
</script> |
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.