You are given two positive integers n and k. A factor of an integer n is defined as an integer i where n % i == 0.

Consider a list of all factors of n sorted in ascending order, return the kth factor in this list or return -1 if n has less than k factors.

&nbsp;
Example 1:

Input: n = 12, k = 3
Output: 3
Explanation: Factors list is [1, 2, 3, 4, 6, 12], the 3rd factor is 3.


Example 2:

Input: n = 7, k = 2
Output: 7
Explanation: Factors list is [1, 7], the 2nd factor is 7.


Example 3:

Input: n = 4, k = 4
Output: -1
Explanation: Factors list is [1, 2, 4], there is only 3 factors. We should return -1.


&nbsp;
Constraints:


	1 &lt;= k &lt;= n &lt;= 1000


&nbsp;
Follow up:

Could you solve this problem in less than O(n) complexity?

class Solution:
    def kthFactor(self, n: int, k: int) -> int:
        start=[1]
        end=[n]
        for i in range(2,math.ceil(math.sqrt(n))+1):
            if n%i==0:
                start.append(i)
                if i!=n//i:
                    end.append(n//i)
        start=sorted(set(start).union(set(end)))
        if k<=len(start):
            return start[k-1]
        else:
            return -1
class Solution {
    public int kthFactor(int n, int k) {
    ArrayList<Integer> list = new ArrayList<>();

        for (int i = 1; i <= n; i++) {

            if (n % i == 0){
                list.add(i);
            }
        }
        if (list.size() < k){
            return -1;
        }
        
        return list.get(k-1);
    }
}
class Solution {
public:
    int kthFactor(int n, int k) {
        vector<int> sol;
        sol.push_back(1);
        for(int i = 2; i <= n / 2; i++) {
            if(n % i == 0) sol.push_back(i);
        }
        if(n != 1) sol.push_back(n);
        if(k > sol.size()) return -1;
        return sol[k - 1];
    }
};
/**
 * @param {number} n
 * @param {number} k
 * @return {number}
 */
var kthFactor = function(n, k) {
    const res = [1]
    for(let i=2; i<n; i++){
        if(n%i === 0){
            res.push(i)
        }
    }
    res.push(n)
    return res[k-1] || -1
};
The kth Factor of n