Nếu bạn đã từng học về các số nguyên tố trong lớp toán, có lẽ bạn đã phải, tại một thời điểm, xác định xem một số có phải là số nguyên tố hay không. Có lẽ bạn đã nhầm lẫn trong khi bạn vẫn đang học chúng, ví dụ, nhầm 39 là số nguyên tố. Chà, đừng lo lắng, vì 39 là một bán kết, tức là nó là sản phẩm của hai số nguyên tố.

Tương tự, chúng ta có thể định nghĩa một số nguyên tố cực đại k là tích của các số nguyên tố k . Ví dụ, 40 là số 4 gần như nguyên tố; 40 = 5 * 2 * 2 * 2, tích của 4 yếu tố.

Nhiệm vụ của bạn là viết một chương trình / hàm chấp nhận hai số nguyên n và k làm đầu vào và đầu ra / trả về số nguyên tố thứ n thứ k . Đây là một môn đánh gôn, vì vậy chương trình ngắn nhất tính bằng byte sẽ thắng.

Các trường hợp thử nghiệm

n, k => output
n, 1 => the nth prime number
1, 1 => 2
3, 1 => 5
1, 2 => 4
3, 2 => 9
5, 3 => 27

Linh tinh

Bạn phải tự tạo các số nguyên tố bằng bất kỳ phương tiện nào khác ngoài một dạng đóng đơn giản, nếu một dạng đóng như vậy tồn tại.

Bình thường, 9 byte

e.fqlPZQE

Giải trình

          - 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]

Hãy thử nó ở đây!

Hoặc thử một bộ thử nghiệm!

Brachylog , 9 byte

Đánh bại @sundar bằng cách sử dụng một nửa số byte

{~l~ḋ}ᶠ⁽t

Giải trình

                    --  Input like [n,k]
{    }ᶠ⁽            --      Find the first n values which
   ~ḋ               --          have a prime decomposition
 ~l                 --          of length k
        t           --      and take the last one

Hãy thử trực tuyến!

Pyke (cam kết 29), 8 byte (không cạnh tranh)

.fPlQq)e

Giải trình:

         - 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]

Julia, 84 78 59 57 byte

f(n,k,i=1)=n>0?f(n-(sum(values(factor(i)))==k),k,i+1):i-1

Đây là hàm đệ quy chấp nhận hai số nguyên và trả về một số nguyên. Cách tiếp cận ở đây là kiểm tra tổng của số mũ trong hệ số nguyên tố so với k.

Ung dung:

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

Thạch, 9 byte

ÆfL=³
ç#Ṫ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Ç#Ṫ    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).

Brachylog , 18 byte

,1{hH&t<NḋlH;N}ⁱ⁽t

Hãy thử trực tuyến!

                      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

Toán học, 56 51 byte

Last@Select[Range[2^##],PrimeOmega@#==n&/.n->#2,#]&

Cảnh báo: Đây là lý thuyết. Không chạy cho bất kỳ giá trị> 4. Thay thế 2 ^ ## bằng một biểu thức hiệu quả hơn.

Toán học, 53 49 byte

Cases[Range[2^(#2+#)],x_/;PrimeOmega@x==#2][[#]]&

Tạo một danh sách các số nguyên dựa trên giới hạn trên lỏng lẻo. PrimeOmegađếm các thừa số nguyên tố với bội, các k -almost thủ Casesđược lấy từ danh sách, và n th thành viên của nhóm được trả về.

Haskell, 88 byte

Có lẽ có thể chơi golf nhiều hơn nữa, vì tôi vẫn là người mới chơi Haskell. Hàm qtrả về số lượng các yếu tố của đối số của nó và fsử dụng hàm đó để lấy nthphần tử của danh sách được tạo từ tất cả các số có kcác yếu tố.

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

MATL, 14 byte

:YqiZ^!XpSu1G)

Dùng thử trên MATL Online

:               % 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

Python 3, 100 byte

Đây là một chức năng vũ phu rất đơn giản. Nó sẽ kiểm tra tất cả các số bắt đầu từ 2 với sympy's factorintchức năng cho đến khi nó đã tìm thấy n ksố nguyên tố -almost, tại thời điểm đó, hàm trả về nthứ trong số này.

import sympy
def a(n,k):
 z=1;c=0
 while c<n:z+=1;c+=(sum(sympy.factorint(z).values())==k)
 return z

Ung dung:

Tôi sử dụng sum(factorint(a).values())vì factorinttrả về một từ điển của các factor: exponentcặp. Grabbing các giá trị của từ điển (các số mũ) và tổng hợp chúng nói với tôi bao nhiêu thừa số nguyên tố có và do đó những gì knày kThủ -almost là.

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

Python 2 , 76 byte

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)

Hãy thử trực tuyến!