[Question]
  [
If you've ever learned about primes in math class, you've probably have had to, at one point, determine if a number is prime. You've probably messed up while you were still learning them, for example, mistaking 39 for a prime. Well, not to worry, as 39 is a semiprime, i.e., that it is the product of two primes.
Similarly, we can define a *k*-almost prime as being the product of *k* prime numbers. For example, 40 is the 4th 4-almost prime; 40 = 5\*2\*2\*2, the product of 4 factors.
Your task is to write a program/function that accepts two integers *n* and *k* as input and output/return the *n*th *k*-almost prime number. This is a code-golf, so the shortest program in bytes wins.
## Test cases
```
n, k => output
n, 1 => the nth prime number
1, 1 => 2
3, 1 => 5
1, 2 => 4
3, 2 => 9
5, 3 => 27
```
# Miscellaneous
You have to generate the primes yourself by any means other than a simple closed form, if such a closed form exists.
  
[Answer]
## Pyth, 9 bytes
```
e.fqlPZQE
```
Explanation
```
          - autoassign Q = eval(input())
     PZ   -      prime_factors(Z) 
    l     -     len(^)
   q   Q  -    ^ == Q
 .f     E -  first eval(input()) of (^ for Z in range(inf))
e         - ^[-1]
```
[Try it here!](http://pyth.herokuapp.com/?code=e.fqlPZQE&input=3%0A5&debug=0)
[Or try a test suite!](http://pyth.herokuapp.com/?code=e.fqlPZQE&input=3%0A5&test_suite=1&test_suite_input=1%0A1%0A1%0A3%0A2%0A1%0A2%0A3%0A3%0A5&debug=0&input_size=2)
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 9 bytes
Beating @sundar by using half as much bytes
```
{~l~ḋ}ᶠ⁽t
```
# Explanation
```
                    --  Input like [n,k]
{    }ᶠ⁽            --      Find the first n values which
   ~ḋ               --          have a prime decomposition
 ~l                 --          of length k
        t           --      and take the last one
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r/v7oup@7hju7ah9sWPGrcW/L/f7SpjnHs/ygA "Brachylog – Try It Online")
[Answer]
# Jelly, 9 bytes
```
ÆfL=³
ç#Ṫ
```
[Try it online!](http://jelly.tryitonline.net/#code=w4ZmTD3CswrDhyPhuao&input=&args=Mw+NQ)
### How it works
```
Ç#Ṫ    Main link. Left input: k. Right input: n.
Ç      Apply the helper link to k, k + 1, k + 2, ... until...
 #       n matches are found.
  Ṫ    Retrieve the last match.
ÆfL=³  Helper link. Left argument: k (iterator)
Æf     Yield the prime factors of k.
  L    Compute the length of the list, i.e., the number of prime factors.
   =³  Compare the result with k (left input).
```
[Answer]
## [Pyke](https://github.com/muddyfish/PYKE/tree/9e0140f09cee5922e3931615c31216eb387738ce) (commit 29), 8 bytes (noncompetitive)
```
.fPlQq)e
```
Explanation:
```
         - autoassign Q = eval_or_not(input())
.f    )  - First eval_or_not(input) of (^ for i in range(inf))
  P      -    prime_factors(i)
   l     -   len(^)
     q   -  ^==V
    Q    -   Q
       e - ^[-1]
```
[Answer]
# Julia, ~~84~~ ~~78~~ ~~59~~ 57 bytes
```
f(n,k,i=1)=n>0?f(n-(sum(values(factor(i)))==k),k,i+1):i-1
```
This is a recursive function that accepts two integers and returns an integer. The approach here is to check the sum of the exponents in the prime factorization against `k`.
Ungolfed:
```
function f(n, k, i=1)
    # We initialize a counter i as a function argument.
    # Recurse while we've encountered fewer than n k-almost primes
    if n > 0
        # If the sum of the exponents in the prime factorization of i is
        # equal to k, there are k prime factors of i. We subtract a boolean
        # from n, which is implicitly cast to an integer, which will
        # decrement n if i is k-almost prime and leave it as is otherwise.
        return f(n - (sum(values(factor(i))) == k), k, i + 1)
    else
        # Otherwise we return i-1 (i will have been incremented one too
        # many times, hence the -1)
        return i - 1
    end
end
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 8 bytes
```
λǐL⁰=;ȯt
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLOu8eQTOKBsD07yK90IiwiIiwiNVxuMyJd)
```
λ    ;ȯt # Nth number where
 ǐL      # Prime factor length
   ⁰=    # Equal to input
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 18 bytes
```
,1{hH&t<NḋlH;N}ⁱ⁽t
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r/X8ewOsNDrcTG7@GO7hwPa7/aR40bHzXuLfn/P9pUR8E49n8UAA "Brachylog – Try It Online")
```
                      Implicit input, say [5, 3]
,1                    Append 1 to the input list. [5, 3, 1]
  {           }ⁱ⁽     Repeat this predicate the number of times given by
                        the first element of the list (5),
                        on the rest of the list [3, 1]
   hH&                Let's call the first element H
      t<N             There is a number N greater than the second element
         ḋ            Whose prime factorization's
          l           length
           H          is equal to H
            ;N        Then, pair that N with H and let that be input for
                      the next iteration
                 t    At the end of iterations, take the last N
                      This is implicitly the output
```
[Answer]
# [Sidef](https://github.com/trizen/sidef), 21 bytes
```
nth_almost_prime(n,k)
```
[Answer]
# Mathematica, ~~56~~ 51 bytes
```
Last@Select[Range[2^##],PrimeOmega@#==n&/.n->#2,#]&
```
Warning: This is theoretical. Do not run for any values>4. Replace 2^## with a more efficient expression.
[Answer]
# Mathematica, ~~53~~ 49 Bytes
```
Cases[Range[2^(#2+#)],x_/;PrimeOmega@x==#2][[#]]&
```
Generates a list of integers based on a loose upper bound. `PrimeOmega` counts the prime factors with multiplicities, the *k*-almost prime `Cases` are taken from the list, and the *n*th member of that subset is returned.
[Answer]
# Haskell, 88 bytes
Can probably be golfed a lot more, as I'm still a newbie to Haskell. The function `q` returns the number of factors of its argument, and `f` uses that to get take the `nth` element of a list made from all numbers that have `k` factors.
```
q n|n<2=0|1>0=1+q(div n ([x|x<-[2..],mod n x<1]!!0))
f n k=filter(\m->q m==k)[1..]!!n-1
```
[Answer]
# MATL, 14 bytes
```
:YqiZ^!XpSu1G)
```
[Try it on MATL Online](https://matl.io/?code=%3AYqiZ%5E%21XpSu1G%29&inputs=5%0A3&version=20.9.2)
```
:               % Take first input n implicitly, make range 1 to n
 Yq             % Get corresponding prime numbers (1st prime to nth prime)
   i            % Take the second input k
    Z^          % Take the k-th cartesian power of the primes list 
                % (Getting all combinations of k primes)
      !Xp       % Multiply each combination (2*2*2, 2*2*3, 2*2*5, ...)
         Su     % Sort and unique
           1G)  % Take the n-th element of the result
```
[Answer]
# Python 3, 100 bytes
This is a very simple brute force function. It checks every number starting from 2 with `sympy`'s `factorint` function until it has found `n` `k`-almost primes, at which point, the function returns the `n`th of these.
```
import sympy
def a(n,k):
 z=1;c=0
 while c<n:z+=1;c+=(sum(sympy.factorint(z).values())==k)
 return z
```
**Ungolfed:**
I use `sum(factorint(a).values())` because `factorint` returns a dictionary of `factor: exponent` pairs. Grabbing the values of the dictionary (the exponents) and summing them tells me how many prime factors there are and thus what `k` this `k`-almost prime is.
```
from sympy import factorint
def almost(n, k):
    z = 1
    count = 0
    while count < n: 
        z += 1
        if sum(factorint(a).values()) == k:
            count += 1
    return z
```
[Answer]
# [Python 2](https://docs.python.org/2/), 76 bytes
```
f=lambda n,k,p=2,c=0:c==k if p>n else f(n,k,p+1,c)if n%p else f(n/p,k,p,c+1)
```
[Try it online!](https://tio.run/##TY0xDgIhEEVrOcU0JpCdRNhYbYIXMRaIjBLW2Qlu4@lxsTC2772fL@/1sfDYGvk5PK@3AIwFxY8YvZ2i9wUygZwY0vxKQPqrB4fRbJz38uMH6Qbj4EyjpcI2ZKiB70k7PJpJ7aRmXqHgOUMP8l9grek/pDMWc1GqfQA "Python 2 – Try It Online")
]