Queries for Nth smallest character for a given range in a string

Given a string str which consists of only lowercase letters and an array arr[][] that represents range queries on the given string str where each query contains 3 integers, {L, R, N} such that for each query we have to output the N^th smallest character in the given range [L, R] as specified in the query. 
Examples: 
 

Input: str = “afbccdeb”, arr[][] = {{2, 4, 1}, {1, 6, 4}, {1, 8, 7}} 
Output: b c e 
Explanation: 
1^st smallest character in range [2, 4] or in the sub-string “fbc” is ‘b’ 
4^th smallest character in range [1, 6] or in the sub-string “afbccd” is ‘c’ 
7^th smallest character in range [1, 8] or in the whole string is ‘e’
Input: str = “geeksforgeeks”, arr[][] = {{1, 4, 2}, {3, 7, 3}, {4, 13, 4}} 
Output: e k g 
Explanation: 
2^nd smallest character in range [1, 4] or in the sub-string “geek” is ‘e’ 
3^rd smallest character in range [3, 7] or in the sub-string “eksfo” is ‘k’ 
4^th smallest character in range [4, 13] or in the sub-string “sforgeeks”is ‘g’ 
 

Naive Approach: A naive approach is to run a loop from L to R and generate a substring in this range. Once the substring is found, sort the substring to find N^th character in the sorted string. 
Time Complexity Analysis: 

• In the worst case, traversing from L to R will have a complexity of O(N).
• Sorting a substring takes a complexity of O(N * Log(N)).
• Since we are sorting the substring for every query, therefore, the overall time complexity is O(N² * Log(N)).

Efficient Approach: The idea is to make use of a two-dimensional hash table. The hash table H[][] is initialized for N rows and 26 columns where N represents the length of the string and 26 as there are a total of 26 lowercase letters. 
The idea behind hashtable is that for each index i where ‘i’ ranges from 1 to N, we keep a track of the number of occurrence of each of the 26 lowercase letters on or before the i^th index. To do this, hashing is used where each character is treated as a number in the following way: 
 

'a' -> 0
'b' -> 1
.
.
.
'z' -> 25

Therefore, for each query {L, R, N}, we get the occurrence of each character for the given range by subtracting the elements of H[L – 1][j] from H[R][j] where j ranges from 0 to 25 in the form of a hash table. After this, all we need to do is traverse from 0 to 25 and add the contents of the resultant array. Whenever the sum is equal to or exceeds N, the character representing that index is the required answer. 
For example, if on 5^th index(j = 4), the sum till then exceeds N, the answer becomes ‘e’ as 4 is equivalent to the character ‘e’. Below is the pictorial representation of the sample case:
 

The image describes the hashtable corresponding to the given string. For range [2, 4], we perform subtraction of the contents from H[2 – 1] from H[4]. We get: 
 

Clearly this resultant array contains the count of elements that are within the range [2, 4]. So we simply traverse from 0 to 25 and count the contents until we reach N. In the query for N = 1 the answer is ‘b’, for N = 2 the answer becomes ‘c’ and so on.
Below is the implementation of the above approach:
 

b
c
e

Time Complexity Analysis: 
 

• For the above approach, though the preprocessing consists of two loops, the second loop runs for a constant number of times(26). Therefore, the time taken for preprocessing is O(N).
• After preprocessing, for every query, the character is returned in constant time as again here the for loop runs a constant number of times(26). Therefore, the time taken for answering each query is O(1).