# Find the k-th smallest divisor of a natural number N

You’re given a number **N** and a number **K**. Our task is to find the **k ^{th}** smallest divisor of

**N**.

**Examples:**

Input :N = 12, K = 5Output :6 The divisors of 12 after sorting are 1, 2, 3, 4, 6 and 12. Where the value of 5^{th}divisor is equal to 6.Input :N = 16, K 2Output :2

**Simple Approach:** A simple approach is to run a loop from 1 to √N and find all factors of N and push them into a vector. Finally, sort the vector and print the K-th value from the vector.

**Note**: Elements in the vector will not be sorted initially as we are pushing both factors (i) and (n/i). That is why it is needed to sort the vector before printing the K-th factor.

Below is the implementation of above approach :

## C++

`// C++ program to find K-th smallest factor ` ` ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// function to find the k'th divisor ` `void` `findkth(` `int` `n, ` `int` `k) ` `{ ` ` ` `// initialize a vector v ` ` ` `vector<` `long` `long` `> v; ` ` ` ` ` `// store all the divisors ` ` ` `// so the loop will needs to run till sqrt ( n ) ` ` ` `for` `(` `int` `i = 1; i <= ` `sqrt` `(n); i++) { ` ` ` `if` `(n % i == 0) { ` ` ` `v.push_back(i); ` ` ` `if` `(i != ` `sqrt` `(n)) ` ` ` `v.push_back(n / i); ` ` ` `} ` ` ` `} ` ` ` ` ` `// sort the vector in an increasing order ` ` ` `sort(v.begin(), v.end()); ` ` ` ` ` `// if k is greater than the size of vector ` ` ` `// then no divisor can be possible ` ` ` `if` `(k > v.size()) ` ` ` `cout << ` `"Doesn't Exist"` `; ` ` ` `// else print the ( k - 1 )th value of vector ` ` ` `else` ` ` `cout << v[k - 1]; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `n = 15, k = 2; ` ` ` ` ` `findkth(n, k); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program to find K-th smallest factor ` `from` `math ` `import` `sqrt ` ` ` `# function to find the k'th divisor ` `def` `findkth(n, k): ` ` ` ` ` `# initialize a vector v ` ` ` `v ` `=` `[] ` ` ` ` ` `# store all the divisors so the loop ` ` ` `# will needs to run till sqrt ( n ) ` ` ` `p ` `=` `int` `(sqrt(n)) ` `+` `1` ` ` `for` `i ` `in` `range` `(` `1` `, p, ` `1` `): ` ` ` `if` `(n ` `%` `i ` `=` `=` `0` `): ` ` ` `v.append(i) ` ` ` `if` `(i !` `=` `sqrt(n)): ` ` ` `v.append(n ` `/` `i); ` ` ` ` ` `# sort the vector in an increasing order ` ` ` `v.sort(reverse ` `=` `False` `) ` ` ` ` ` `# if k is greater than the size of vector ` ` ` `# then no divisor can be possible ` ` ` `if` `(k > ` `len` `(v)): ` ` ` `print` `(` `"Doesn't Exist"` `) ` ` ` ` ` `# else print the (k - 1)th ` ` ` `# value of vector ` ` ` `else` `: ` ` ` `print` `(v[k ` `-` `1` `]) ` ` ` `# Driver code ` `if` `__name__ ` `=` `=` `'__main__'` `: ` ` ` `n ` `=` `15` ` ` `k ` `=` `2` ` ` ` ` `findkth(n, k) ` ` ` `# This code is contributed by ` `# Surendra_Gangwar ` |

*chevron_right*

*filter_none*

**Output:**

3

**Time Complexity**: √N log( √N )

**Efficient Approach**: An efficient approach will be to store the factors in two separate vectors. That is, factors i will be stored in a separate vector and N/i will be stored in a separate vector for all i from 1 to √N.

Now, if observed carefully, it can be seen that the first vector is already sorted in increasing order and the second vector is sorted in decreasing order. So, reverse the second vector and print the K-th element from either of the vectors in which it is lying.

Below is the implementation of the above approach:

## C++

`// C++ program to find the K-th smallest factor ` ` ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function to find the k'th divisor ` `void` `findkth ( ` `int` `n, ` `int` `k) ` `{ ` ` ` `// initialize vectors v1 and v2 ` ` ` `vector <` `int` `> v1; ` ` ` `vector <` `int` `> v2; ` ` ` ` ` `// store all the divisors in the two vectors ` ` ` `// accordingly ` ` ` `for` `( ` `int` `i = 1 ; i <= ` `sqrt` `( n ); i++ ) ` ` ` `{ ` ` ` `if` `( n % i == 0 ) ` ` ` `{ ` ` ` `v1.push_back ( i ); ` ` ` ` ` `if` `( i != ` `sqrt` `( n ) ) ` ` ` `v2.push_back ( n / i ); ` ` ` `} ` ` ` `} ` ` ` ` ` `// reverse the vector v2 to sort it ` ` ` `// in increasing order ` ` ` `reverse(v2.begin(), v2.end()); ` ` ` ` ` `// if k is greater than the size of vectors ` ` ` `// then no divisor can be possible ` ` ` `if` `( k > (v1.size() + v2.size())) ` ` ` `cout << ` `"Doesn't Exist"` `; ` ` ` `// else print the ( k - 1 )th value of vector ` ` ` `else` ` ` `{ ` ` ` `// If K is lying in first vector ` ` ` `if` `(k <= v1.size()) ` ` ` `cout<<v1[k-1]; ` ` ` `// If K is lying in second vector ` ` ` `else` ` ` `cout<<v2[k-v1.size()-1]; ` ` ` `} ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `n = 15, k = 2; ` ` ` ` ` `findkth ( n, k) ; ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program to find the K-th ` `# smallest factor ` `import` `math as mt ` ` ` `# Function to find the k'th divisor ` `def` `findkth (n, k): ` ` ` ` ` `# initialize vectors v1 and v2 ` ` ` `v1 ` `=` `list` `() ` ` ` `v2 ` `=` `list` `() ` ` ` ` ` `# store all the divisors in the ` ` ` `# two vectors accordingly ` ` ` `for` `i ` `in` `range` `(` `1` `, mt.ceil(n` `*` `*` `(.` `5` `))): ` ` ` ` ` `if` `(n ` `%` `i ` `=` `=` `0` `): ` ` ` ` ` `v1.append(i) ` ` ` ` ` `if` `(i !` `=` `mt.ceil(mt.sqrt(n))): ` ` ` `v2.append(n ` `/` `/` `i) ` ` ` ` ` `# reverse the vector v2 to sort it ` ` ` `# in increasing order ` ` ` `v2[::` `-` `1` `] ` ` ` ` ` `# if k is greater than the size of vectors ` ` ` `# then no divisor can be possible ` ` ` `if` `( k > (` `len` `(v1) ` `+` `len` `(v2))): ` ` ` `print` `(` `"Doesn't Exist"` `, end ` `=` `"") ` ` ` ` ` `# else print the ( k - 1 )th value of vector ` ` ` `else` `: ` ` ` ` ` `# If K is lying in first vector ` ` ` `if` `(k <` `=` `len` `(v1)): ` ` ` `print` `(v1[k ` `-` `1` `]) ` ` ` ` ` `# If K is lying in second vector ` ` ` `else` `: ` ` ` `print` `(v2[k ` `-` `len` `(v1) ` `-` `1` `]) ` ` ` `# Driver code ` `n ` `=` `15` `k ` `=` `2` `findkth (n, k) ` ` ` `# This code is contributed by Mohit kumar ` |

*chevron_right*

*filter_none*

**Output:**

3

**Time Complexity**: √N

## Recommended Posts:

- Greatest divisor which divides all natural number in range [L, R]
- Smallest prime divisor of a number
- Smallest number to multiply to convert floating point to natural
- Smallest divisor D of N such that gcd(D, M) is greater than 1
- Find sum of modulo K of first N natural number
- Find if given number is sum of first n natural numbers
- Find all divisors of a natural number | Set 2
- Find all divisors of a natural number | Set 1
- Find the first natural number whose factorial is divisible by x
- Find the number of sub arrays in the permutation of first N natural numbers such that their median is M
- Find the smallest number whose digits multiply to a given number n
- Find smallest number K such that K % p = 0 and q % K = 0
- Find an integer X which is divisor of all except exactly one element in an array
- K-th smallest element after removing given integers from natural numbers | Set 2
- Find smallest permutation of given number

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.