# Kth smallest Prime Number in range L to R for Q queries

• Last Updated : 11 Jan, 2022

Given three variables L, R and Q which denotes the range [L, R] and total number of queries. For each query there will be a variable K. The task is to find Kth smallest prime number in range [L, R]. If K is greater than count of prime numbers in the range [L, R] then return -1.

Examples:

Input: Q = 3, L = 5, R = 20
queries: K = 4,
K = 3,
K = 9
Output: 13 11 -1
Explanation:  The prime numbers in the given range are 5, 7, 11, 13, 17, 19 and
the 4th and 3rd smallest prime numbers are 13 and 11.

Input: Q = 1, L = 15, R = 32
queries: K = 3
Output: 23

Approach: The given problem can be solved with the help of Sieve of Eratosthenes method:
When the algorithm terminates, all the numbers in the list that are not marked are prime. Follow the steps mentioned below:

• Run Sieve of Eratosthenes for number in range [L, R]
• For each query find the Kth smallest prime from the calculated primes.
• If K exceeds the number of primes in that range, return -1.

See the illustration below for better understanding of Sieve of Eratosthenes.

Illustration: Take range [20, 40]
Sieve of Eratosthenes will help in finding the primes in this range.
Create a list of all numbers from 1 to 40. According to the algorithm mark all the non-prime numbers in the given range.
So the prime numbers are the unmarked ones: 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37.
The primes in range [20, 40] are: 23, 29, 31 and 37

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;` `vector<``int``> primes;`   `// Function to implement ` `// Sieve Of Eratosthenes` `void` `sieveOfEratosthenes(``int` `R)` `{` `    ``primes.assign(R + 1, 0);` `    ``primes = 1;` `    ``for` `(``int` `i = 2; i * i <= R; i++) {` `        ``if` `(primes[i] == 0) {` `            ``for` `(``int` `j = i + i; j <= R; ` `                 ``j += i)` `                ``primes[j] = 1;` `        ``}` `    ``}` `}`   `// Function to return Kth smallest` `// prime number if it exists` `int` `kthSmallest(``int` `L, ``int` `R, ``int` `K)` `{` `    ``// To count the prime number` `    ``int` `count = 0;`   `    ``// Loop to iterate the from L to R` `    ``for` `(``int` `i = L; i <= R; i++) {`   `        ``// Calculate the count Of` `        ``// primes numbers` `        ``if` `(primes[i] == 0) {` `            ``count++;` `        ``}`   `        ``// if count equals K, then` `        ``// Kth smallest prime number is` `        ``// found then return the number` `        ``if` `(count == K) {` `            ``return` `i;` `        ``}` `    ``}`   `    ``// Kth smallest prime number is not in` `    ``// this range then return -1` `    ``return` `-1;` `}`   `// Driver Code` `int` `main()` `{` `    ``// No of Queries` `    ``int` `Q = 3;` `    ``int` `L, R, K;` `    ``L = 5, R = 20;` `    ``sieveOfEratosthenes(R);`   `    ``// First Query` `    ``K = 4;` `    ``cout << kthSmallest(L, R, K) << endl;`   `    ``// Second Query` `    ``K = 3;` `    ``cout << kthSmallest(L, R, K) << endl;`   `    ``// Third Query` `    ``K = 5;` `    ``cout << kthSmallest(L, R, K) << endl;` `    ``return` `0;` `}`

## Java

 `// Java code to implement the above approach` `import` `java.util.*;` `public` `class` `GFG` `{`   `  ``static` `int` `primes[] = ``new` `int``[``1000``];`   `  ``// Function to implement ` `  ``// Sieve Of Eratosthenes` `  ``static` `void` `sieveOfEratosthenes(``int` `R)` `  ``{`   `    ``for``(``int` `i = ``0``; i < R + ``1``; i++) {` `      ``primes[i] = ``0``;` `    ``}`   `    ``primes[``1``] = ``1``;` `    ``for` `(``int` `i = ``2``; i * i <= R; i++) {` `      ``if` `(primes[i] == ``0``) {` `        ``for` `(``int` `j = i + i; j <= R; ` `             ``j += i)` `          ``primes[j] = ``1``;` `      ``}` `    ``}` `  ``}`   `  ``// Function to return Kth smallest` `  ``// prime number if it exists` `  ``static` `int` `kthSmallest(``int` `L, ``int` `R, ``int` `K)` `  ``{` `    ``// To count the prime number` `    ``int` `count = ``0``;`   `    ``// Loop to iterate the from L to R` `    ``for` `(``int` `i = L; i <= R; i++) {`   `      ``// Calculate the count Of` `      ``// primes numbers` `      ``if` `(primes[i] == ``0``) {` `        ``count++;` `      ``}`   `      ``// if count equals K, then` `      ``// Kth smallest prime number is` `      ``// found then return the number` `      ``if` `(count == K) {` `        ``return` `i;` `      ``}` `    ``}`   `    ``// Kth smallest prime number is not in` `    ``// this range then return -1` `    ``return` `-``1``;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main(String args[])` `  ``{` `    ``// No of Queries` `    ``int` `Q = ``3``;` `    ``int` `L = ``5``, R = ``20``;` `    ``sieveOfEratosthenes(R);`   `    ``// First Query` `    ``int` `K = ``4``;` `    ``System.out.println(kthSmallest(L, R, K));`   `    ``// Second Query` `    ``K = ``3``;` `    ``System.out.println(kthSmallest(L, R, K));`   `    ``// Third Query` `    ``K = ``5``;` `    ``System.out.println(kthSmallest(L, R, K));`   `  ``}` `}`   `// This code is contributed by Samim Hossain Mondal.`

## Python3

 `# Python code to implement the above approach` `primes ``=` `[``0` `for` `i ``in` `range``(``1000``)];`   `# Function to implement` `# Sieve Of Eratosthenes` `def` `sieveOfEratosthenes(R):` `    ``for` `i ``in` `range``(``0``, R ``+` `1``):` `        ``primes[i] ``=` `0``;`   `    ``primes[``1``] ``=` `1``;` `    ``for` `i ``in` `range``(``2``, ``pow``(R, ``2``) ``+` `1``):` `        ``if` `(primes[i] ``=``=` `0``):` `            ``for` `j ``in` `range``(i ``+` `i, R ``+` `1``, i):` `                ``primes[j] ``=` `1``;`   `# Function to return Kth smallest` `# prime number if it exists` `def` `kthSmallest(L, R, K):` `  `  `    ``# To count the prime number` `    ``count ``=` `0``;`   `    ``# Loop to iterate the from L to R` `    ``for` `i ``in` `range``(L,R``+``1``):`   `        ``# Calculate the count Of` `        ``# primes numbers` `        ``if` `(primes[i] ``=``=` `0``):` `            ``count ``+``=` `1``;`   `        ``# if count equals K, then` `        ``# Kth smallest prime number is` `        ``# found then return the number` `        ``if` `(count ``=``=` `K):` `            ``return` `i;`   `    ``# Kth smallest prime number is not in` `    ``# this range then return -1` `    ``return` `-``1``;`   `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    ``# No of Queries` `    ``Q ``=` `3``;` `    ``L ``=` `5``; R ``=` `20``;` `    ``sieveOfEratosthenes(R);`   `    ``# First Query` `    ``K ``=` `4``;` `    ``print``(kthSmallest(L, R, K));`   `    ``# Second Query` `    ``K ``=` `3``;` `    ``print``(kthSmallest(L, R, K));`   `    ``# Third Query` `    ``K ``=` `5``;` `    ``print``(kthSmallest(L, R, K));`   `# This code is contributed by shikhasingrajput`

## C#

 `// C# code to implement the above approach` `using` `System;` `class` `GFG` `{`   `  ``static` `int` `[]primes = ``new` `int``;`   `  ``// Function to implement ` `  ``// Sieve Of Eratosthenes` `  ``static` `void` `sieveOfEratosthenes(``int` `R)` `  ``{`   `    ``for``(``int` `i = 0; i < R + 1; i++) {` `      ``primes[i] = 0;` `    ``}`   `    ``primes = 1;` `    ``for` `(``int` `i = 2; i * i <= R; i++) {` `      ``if` `(primes[i] == 0) {` `        ``for` `(``int` `j = i + i; j <= R; ` `             ``j += i)` `          ``primes[j] = 1;` `      ``}` `    ``}` `  ``}`   `  ``// Function to return Kth smallest` `  ``// prime number if it exists` `  ``static` `int` `kthSmallest(``int` `L, ``int` `R, ``int` `K)` `  ``{` `    ``// To count the prime number` `    ``int` `count = 0;`   `    ``// Loop to iterate the from L to R` `    ``for` `(``int` `i = L; i <= R; i++) {`   `      ``// Calculate the count Of` `      ``// primes numbers` `      ``if` `(primes[i] == 0) {` `        ``count++;` `      ``}`   `      ``// if count equals K, then` `      ``// Kth smallest prime number is` `      ``// found then return the number` `      ``if` `(count == K) {` `        ``return` `i;` `      ``}` `    ``}`   `    ``// Kth smallest prime number is not in` `    ``// this range then return -1` `    ``return` `-1;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `Main()` `  ``{` `    ``// No of Queries` `    ``int` `Q = 3;` `    ``int` `L = 5, R = 20;` `    ``sieveOfEratosthenes(R);`   `    ``// First Query` `    ``int` `K = 4;` `    ``Console.WriteLine(kthSmallest(L, R, K));`   `    ``// Second Query` `    ``K = 3;` `    ``Console.WriteLine(kthSmallest(L, R, K));`   `    ``// Third Query` `    ``K = 5;` `    ``Console.WriteLine(kthSmallest(L, R, K));`   `  ``}` `}`   `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

```13
11
17```

Time Complexity: O(N * log(log N)))
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Recommended Articles
Page :