# Find the Kth smallest element in the sorted generated array

Given an array arr[] of N elements and an integer K, the task is to generate an B[] with the following rules:

1. Copy elements arr[1…N], N times to array B[].
2. Copy elements arr[1…N/2], 2*N times to array B[].
3. Copy elements arr[1…N/4], 3*N times to array B[].
4. Similarly, until only no element is left to be copied to array B[].

Finally print the Kth smallest element from the array B[]. If K is out of bounds of B[] then return -1.

Examples:

Input: arr[] = {1, 2, 3}, K = 4
Output: 1
{1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 1, 1, 1, 1, 1} is the required array B[]
{1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 3, 3} in the sorted form where
1 is the 4th smallest element.

Input: arr[] = {2, 4, 5, 1}, K = 13
Output: 2

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

Approach:

1. Maintain a Count_Array where we must store the count of times every element occurs in array B[]. It can be done for range of elements by adding the count at start index and subtracting the same count at end index + 1 location.
2. Take cumulative sum of count array.
3. Maintain all elements of arr[] with their count in Array B[] along with their counts and sort them based on element value.
4. Traverse through vector and see which element has Kth position in B[] as per their individual counts.
5. If K is out of bounds of B[] then return -1.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return the Kth element in B[] ` `int` `solve(``int` `Array[], ``int` `N, ``int` `K) ` `{ ` ` `  `    ``// Initialize the count Array ` `    ``int` `count_Arr[N + 1] = { 0 }; ` `    ``int` `factor = 1; ` `    ``int` `size = N; ` ` `  `    ``// Reduce N repeatedly to half its value ` `    ``while` `(size) { ` `        ``int` `start = 1; ` `        ``int` `end = size; ` ` `  `        ``// Add count to start ` `        ``count_Arr += factor * N; ` ` `  `        ``// Subtract same count after end index ` `        ``count_Arr[end + 1] -= factor * N; ` `        ``factor++; ` `        ``size /= 2; ` `    ``} ` ` `  `    ``for` `(``int` `i = 2; i <= N; i++) ` `        ``count_Arr[i] += count_Arr[i - 1]; ` ` `  `    ``// Store each element of Array[] with their count ` `    ``vector > element; ` `    ``for` `(``int` `i = 0; i < N; i++) { ` `        ``element.push_back({ Array[i], count_Arr[i + 1] }); ` `    ``} ` ` `  `    ``// Sort the elements wrt value ` `    ``sort(element.begin(), element.end()); ` ` `  `    ``int` `start = 1; ` `    ``for` `(``int` `i = 0; i < N; i++) { ` `        ``int` `end = start + element[i].second - 1; ` ` `  `        ``// If Kth element is in range of element[i] ` `        ``// return element[i] ` `        ``if` `(K >= start && K <= end) { ` `            ``return` `element[i].first; ` `        ``} ` ` `  `        ``start += element[i].second; ` `    ``} ` ` `  `    ``// If K is out of bound ` `    ``return` `-1; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 2, 4, 5, 1 }; ` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``int` `K = 13; ` ` `  `    ``cout << solve(arr, N, K); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach  ` `import` `java.util.Vector; ` ` `  `class` `GFG  ` `{ ` ` `  `    ``// Pair class implementation to use Pair ` `    ``static` `class` `Pair ` `    ``{ ` `        ``private` `int` `first; ` `        ``private` `int` `second; ` ` `  `        ``Pair(``int` `first, ``int` `second)  ` `        ``{ ` `            ``this``.first = first; ` `            ``this``.second = second; ` `        ``} ` ` `  `        ``public` `int` `getFirst()  ` `        ``{ ` `            ``return` `first; ` `        ``} ` ` `  `        ``public` `int` `getSecond() ` `        ``{ ` `            ``return` `second; ` `        ``} ` `    ``} ` ` `  `    ``// Function to return the Kth element in B[] ` `    ``static` `int` `solve(``int``[] Array, ``int` `N, ``int` `K) ` `    ``{ ` ` `  `        ``// Initialize the count Array ` `        ``int``[] count_Arr = ``new` `int``[N + ``2``]; ` `        ``int` `factor = ``1``; ` `        ``int` `size = N; ` ` `  `        ``// Reduce N repeatedly to half its value ` `        ``while` `(size > ``0``)  ` `        ``{ ` `            ``int` `start = ``1``; ` `            ``int` `end = size; ` ` `  `            ``// Add count to start ` `            ``count_Arr[``1``] += factor * N; ` ` `  `            ``// Subtract same count after end index ` `            ``count_Arr[end + ``1``] -= factor * N; ` `            ``factor++; ` `            ``size /= ``2``; ` `        ``} ` ` `  `        ``for` `(``int` `i = ``2``; i <= N; i++) ` `            ``count_Arr[i] += count_Arr[i - ``1``]; ` ` `  `        ``// Store each element of Array[] ` `        ``// with their count ` `        ``Vector element = ``new` `Vector<>(); ` `        ``for` `(``int` `i = ``0``; i < N; i++)  ` `        ``{ ` `            ``Pair x = ``new` `Pair(Array[i],  ` `                              ``count_Arr[i + ``1``]); ` `            ``element.add(x); ` `        ``} ` ` `  `        ``int` `start = ``1``; ` `        ``for` `(``int` `i = ``0``; i < N; i++)  ` `        ``{ ` `            ``int` `end = start + element.elementAt(``0``).getSecond() - ``1``; ` ` `  `            ``// If Kth element is in range of element[i] ` `            ``// return element[i] ` `            ``if` `(K >= start && K <= end) ` `                ``return` `element.elementAt(i).getFirst(); ` ` `  `            ``start += element.elementAt(i).getSecond(); ` `        ``} ` ` `  `        ``// If K is out of bound ` `        ``return` `-``1``; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int``[] arr = { ``2``, ``4``, ``5``, ``1` `}; ` `        ``int` `N = arr.length; ` `        ``int` `K = ``13``; ` `        ``System.out.println(solve(arr, N, K)); ` `    ``} ` `}     ` ` `  `// This code is contiributed by ` `// sanjeev2552 `

## Python3

 `# Python3 implementation of the approach  ` ` `  `# Function to return the Kth element in B[]  ` `def` `solve(Array, N, K) :  ` ` `  `    ``# Initialize the count Array  ` `    ``count_Arr ``=` `[``0``]``*``(N ``+` `2``) ;  ` `    ``factor ``=` `1``;  ` `    ``size ``=` `N;  ` ` `  `    ``# Reduce N repeatedly to half its value  ` `    ``while` `(size) : ` `        ``start ``=` `1``;  ` `        ``end ``=` `size;  ` ` `  `        ``# Add count to start  ` `        ``count_Arr[``1``] ``+``=` `factor ``*` `N;  ` ` `  `        ``# Subtract same count after end index  ` `        ``count_Arr[end ``+` `1``] ``-``=` `factor ``*` `N;  ` `        ``factor ``+``=` `1``;  ` `        ``size ``/``/``=` `2``;  ` ` `  `    ``for` `i ``in` `range``(``2``, N ``+` `1``) :  ` `        ``count_Arr[i] ``+``=` `count_Arr[i ``-` `1``];  ` ` `  `    ``# Store each element of Array[] with their count  ` `    ``element ``=` `[]; ` `     `  `    ``for` `i ``in` `range``(N) : ` `        ``element.append(( Array[i], count_Arr[i ``+` `1``] ));  ` ` `  `    ``# Sort the elements wrt value  ` `    ``element.sort();  ` ` `  `    ``start ``=` `1``;  ` `    ``for` `i ``in` `range``(N) : ` `        ``end ``=` `start ``+` `element[i][``1``] ``-` `1``;  ` ` `  `        ``# If Kth element is in range of element[i]  ` `        ``# return element[i]  ` `        ``if` `(K >``=` `start ``and` `K <``=` `end) : ` `            ``return` `element[i][``0``];  ` ` `  `        ``start ``+``=` `element[i][``1``];  ` ` `  `    ``# If K is out of bound  ` `    ``return` `-``1``;  ` ` `  ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `:  ` ` `  `    ``arr ``=` `[ ``2``, ``4``, ``5``, ``1` `];  ` `    ``N ``=` `len``(arr);  ` `    ``K ``=` `13``;  ` ` `  `    ``print``(solve(arr, N, K));  ` ` `  `    ``# This code is contributed by AnkitRai01 `

## C#

 `// C# implementation of the approach ` `using` `System; ` `using` `System.Collections.Generic; ` `     `  `class` `GFG  ` `{ ` ` `  `    ``// Pair class implementation to use Pair ` `    ``public` `class` `Pair ` `    ``{ ` `        ``public` `int` `first; ` `        ``public` `int` `second; ` ` `  `        ``public` `Pair(``int` `first, ``int` `second)  ` `        ``{ ` `            ``this``.first = first; ` `            ``this``.second = second; ` `        ``} ` ` `  `        ``public` `int` `getFirst()  ` `        ``{ ` `            ``return` `first; ` `        ``} ` ` `  `        ``public` `int` `getSecond() ` `        ``{ ` `            ``return` `second; ` `        ``} ` `    ``} ` ` `  `    ``// Function to return the Kth element in B[] ` `    ``static` `int` `solve(``int``[] Array, ``int` `N, ``int` `K) ` `    ``{ ` ` `  `        ``// Initialize the count Array ` `        ``int``[] count_Arr = ``new` `int``[N + 2]; ` `        ``int` `factor = 1; ` `        ``int` `size = N; ` ` `  `        ``// Reduce N repeatedly to half its value ` `        ``while` `(size > 0)  ` `        ``{ ` `            ``int` `end = size; ` ` `  `            ``// Add count to start ` `            ``count_Arr += factor * N; ` ` `  `            ``// Subtract same count after end index ` `            ``count_Arr[end + 1] -= factor * N; ` `            ``factor++; ` `            ``size /= 2; ` `        ``} ` ` `  `        ``for` `(``int` `i = 2; i <= N; i++) ` `            ``count_Arr[i] += count_Arr[i - 1]; ` ` `  `        ``// Store each element of Array[] ` `        ``// with their count ` `        ``List element = ``new` `List(); ` `        ``for` `(``int` `i = 0; i < N; i++)  ` `        ``{ ` `            ``Pair x = ``new` `Pair(Array[i],  ` `                              ``count_Arr[i + 1]); ` `            ``element.Add(x); ` `        ``} ` ` `  `        ``int` `start = 1; ` `        ``for` `(``int` `i = 0; i < N; i++)  ` `        ``{ ` `            ``int` `end = start + element.getSecond() - 1; ` ` `  `            ``// If Kth element is in range of element[i] ` `            ``// return element[i] ` `            ``if` `(K >= start && K <= end) ` `                ``return` `element[i].getFirst(); ` ` `  `            ``start += element[i].getSecond(); ` `        ``} ` ` `  `        ``// If K is out of bound ` `        ``return` `-1; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` `        ``int``[] arr = { 2, 4, 5, 1 }; ` `        ``int` `N = arr.Length; ` `        ``int` `K = 13; ` `        ``Console.WriteLine(solve(arr, N, K)); ` `    ``} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

Output:

```2
```

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.