 Open in App
Not now

# Kth smallest element in an array that contains A[i] exactly B[i] times

• Difficulty Level : Basic
• Last Updated : 13 Jul, 2021

Given two arrays A[] and B[] consisting of N positive integers and an integer K, the task is to find the Kth smallest element in the array formed by taking the ith element from the array A[] exactly B[i] times. If there exists no such element, then print -1.

Examples:

Input: K = 4, A[] = {1, 2, 3}, B[] = {1, 2, 3}
Output: 3
Explanation:
The array obtained by taking A, B (= 1) time, A, B (= 2) times, A, B( = 3)  times is {1, 2, 2, 3, 3, 3}. Therefore, the 4th element of the array is 3.

Input: K = 4, A[] = {3, 4, 5}, B[] = {2, 1, 3}
Output: 3
Explanation:The array formed is {3, 3, 4, 5, 5, 5}. Therefore, the 4th element of the array i.e 5.

Naive Approach: The simplest approach is to iterate over the range [0, N – 1] and push the element at the ith index of the array, B[i] times into the new array. Finally, print the Kth element of the obtained array after sorting the array in ascending order.

Time Complexity: O(N*log(N)), where N is the number of elements in the new array.
Auxiliary Space: O(N)

Efficient Approach: The above approach can be optimized by using a frequency array to keep the count of every element. Follow the steps below to solve the problem:

• Find the maximum element of the array A[] and store it in a variable, say M.
• Initialize an array, say freq[] of size M + 1 with {0}, to store the frequency of every element.
• Iterate in the range [0, N-1] using the variable i:
• Initialize a variable, say sum as 0, to store the prefix sum up to a particular index.
• Iterate over the range [0, N – 1] using a variable, say i:
• If sum is greater than or equal to K, then return i.
• Finally, return -1.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to find the Kth smallest element` `// that contains A[i] exactly B[i] times` `int` `KthSmallest(``int` `A[], ``int` `B[], ``int` `N, ``int` `K)` `{`   `    ``int` `M = 0;`   `    ``// Traverse the given array` `    ``for` `(``int` `i = 0; i < N; i++) {`   `        ``M = max(A[i], M);` `    ``}`   `    ``// Stores the frequency` `    ``// of every elements` `    ``int` `freq[M + 1] = { 0 };`   `    ``// Traverse the given array` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``freq[A[i]] += B[i];` `    ``}`   `    ``// Initialize a variable to` `    ``// store the prefix sums` `    ``int` `sum = 0;`   `    ``// Iterate over the range [0, M]` `    ``for` `(``int` `i = 0; i <= M; i++) {`   `        ``// Increment sum by freq[i]` `        ``sum += freq[i];`   `        ``// If sum is greater` `        ``// than or equal to K` `        ``if` `(sum >= K) {`   `            ``// Return the current` `            ``// element as answer` `            ``return` `i;` `        ``}` `    ``}` `    ``// Return -1` `    ``return` `-1;` `}`   `// Driver Code` `int` `main()` `{`   `    ``// Given Input` `    ``int` `A[] = { 3, 4, 5 };` `    ``int` `B[] = { 2, 1, 3 };` `    ``int` `N = ``sizeof``(A) / ``sizeof``(A);` `    ``int` `K = 4;`   `    ``// Function call` `    ``cout << KthSmallest(A, B, N, K);` `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `public` `class` `GFG_JAVA {`   `    ``// Function to find the Kth smallest element` `    ``// that contains A[i] exactly B[i] times` `    ``static` `int` `KthSmallest(``int` `A[], ``int` `B[], ``int` `N, ``int` `K)` `    ``{`   `        ``int` `M = ``0``;`   `        ``// Traverse the given array` `        ``for` `(``int` `i = ``0``; i < N; i++) {`   `            ``M = Math.max(A[i], M);` `        ``}`   `        ``// Stores the frequency` `        ``// of every elements` `        ``int` `freq[] = ``new` `int``[M + ``1``];`   `        ``// Traverse the given array` `        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``freq[A[i]] += B[i];` `        ``}`   `        ``// Initialize a variable to` `        ``// store the prefix sums` `        ``int` `sum = ``0``;`   `        ``// Iterate over the range [0, M]` `        ``for` `(``int` `i = ``0``; i <= M; i++) {`   `            ``// Increment sum by freq[i]` `            ``sum += freq[i];`   `            ``// If sum is greater` `            ``// than or equal to K` `            ``if` `(sum >= K) {`   `                ``// Return the current` `                ``// element as answer` `                ``return` `i;` `            ``}` `        ``}` `        ``// Return -1` `        ``return` `-``1``;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{ ``// Given Input` `        ``int` `A[] = { ``3``, ``4``, ``5` `};` `        ``int` `B[] = { ``2``, ``1``, ``3` `};` `        ``int` `N = A.length;` `        ``int` `K = ``4``;`   `        ``// Function call` `        ``System.out.println(KthSmallest(A, B, N, K));` `    ``}` `}` `// This code is contributed by abhinavjain194`

## Python3

 `# Python3 program for the above approach`   `# Function to find the Kth smallest element` `# that contains A[i] exactly B[i] times` `def` `KthSmallest(A, B, N, K):`   `    ``M ``=` `0`   `    ``# Traverse the given array` `    ``for` `i ``in` `range``(N):` `        ``M ``=` `max``(A[i], M)`   `    ``# Stores the frequency` `    ``# of every elements` `    ``freq ``=` `[``0``] ``*` `(M ``+` `1``)`   `    ``# Traverse the given array` `    ``for` `i ``in` `range``(N):` `        ``freq[A[i]] ``+``=` `B[i]`   `    ``# Initialize a variable to` `    ``# store the prefix sums` `    ``sum` `=` `0`   `    ``# Iterate over the range [0, M]` `    ``for` `i ``in` `range``(M ``+` `1``):`   `        ``# Increment sum by freq[i]` `        ``sum` `+``=` `freq[i]`   `        ``# If sum is greater` `        ``# than or equal to K` `        ``if` `(``sum` `>``=` `K):`   `            ``# Return the current` `            ``# element as answer` `            ``return` `i` `            `  `    ``# Return -1` `    ``return` `-``1`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"` `:`   `    ``# Given Input` `    ``A ``=` `[ ``3``, ``4``, ``5` `]` `    ``B ``=` `[ ``2``, ``1``, ``3` `]` `    ``N ``=` `len``(A)` `    ``K ``=` `4`   `    ``# Function call` `    ``print``(KthSmallest(A, B, N, K))` `   `  `# This code is contributed by AnkThon`

## C#

 `// C# program for the above approach` `using` `System;`   `class` `GFG{`   `// Function to find the Kth smallest element` `// that contains A[i] exactly B[i] times` `static` `int` `KthSmallest(``int` `[]A, ``int` `[]B, ` `                       ``int` `N, ``int` `K)` `{` `    ``int` `M = 0;`   `    ``// Traverse the given array` `    ``for``(``int` `i = 0; i < N; i++) ` `    ``{` `        ``M = Math.Max(A[i], M);` `    ``}`   `    ``// Stores the frequency` `    ``// of every elements` `    ``int` `[]freq = ``new` `int``[M + 1];`   `    ``// Traverse the given array` `    ``for``(``int` `i = 0; i < N; i++)` `    ``{` `        ``freq[A[i]] += B[i];` `    ``}`   `    ``// Initialize a variable to` `    ``// store the prefix sums` `    ``int` `sum = 0;`   `    ``// Iterate over the range [0, M]` `    ``for``(``int` `i = 0; i <= M; i++)` `    ``{` `        `  `        ``// Increment sum by freq[i]` `        ``sum += freq[i];`   `        ``// If sum is greater` `        ``// than or equal to K` `        ``if` `(sum >= K) ` `        ``{` `            `  `            ``// Return the current` `            ``// element as answer` `            ``return` `i;` `        ``}` `    ``}` `    `  `    ``// Return -1` `    ``return` `-1;` `}`   `// Driver code` `public` `static` `void` `Main(String[] args)` `{   ` `    `  `    ``// Given Input` `    ``int` `[]A = { 3, 4, 5 };` `    ``int` `[]B = { 2, 1, 3 };` `    ``int` `N = A.Length;` `    ``int` `K = 4;`   `    ``// Function call` `    ``Console.Write(KthSmallest(A, B, N, K));` `}` `}`   `// This code is contributed by shivanisinghss2110`

## Javascript

 ``

Output:

`5`

Time Complexity: O(N), where N is the size of arrays A[] and B[].
Auxiliary Space: O(M), where M is the maximum element of the array A[].

My Personal Notes arrow_drop_up
Related Articles