Related Articles

# Find the Kth smallest element in the sorted generated array

• Last Updated : 08 Jun, 2021

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

## Javascript

 ``
Output:
`2`

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up