 Open in App
Not now

# Find the Kth smallest element in the sorted generated array

• Difficulty Level : Medium
• Last Updated : 31 May, 2022

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

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

## Javascript

 ``

Output:

`2`

Time Complexity: O(N * log N)

Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Related Articles