Skip to content
Related Articles

Related Articles

Queries to answer the X-th smallest sub-string lexicographically
  • Difficulty Level : Basic
  • Last Updated : 24 May, 2019

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 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 <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




// 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 */
Output:
e
ek
k



My Personal Notes arrow_drop_up
Recommended Articles
Page :