หากคุณเคยเรียนรู้เรื่องช่วงเวลาในชั้นเรียนคณิตศาสตร์มาก่อนคุณอาจต้องลองดูว่าตัวเลขนั้นดีหรือไม่ คุณอาจจะสับสนในขณะที่คุณยังคงเรียนรู้พวกเขาเช่นเข้าใจผิด 39 สำหรับนายก ก็ไม่ต้องกังวลเพราะ 39 เป็นเซมิโคลนคือมันเป็นผลคูณของสองช่วง

ในทำนองเดียวกันเราสามารถกำหนดk- ที่สำคัญที่สุดว่าเป็นผลิตภัณฑ์ของตัวเลขที่k ตัวอย่างเช่น 40 เป็นอันดับ 4 อันดับที่ 4 เกือบ 40 = 5 * 2 * 2 * 2 ผลิตภัณฑ์ 4 ปัจจัย

งานของคุณคือการเขียนโปรแกรม / ฟังก์ชั่นที่รับจำนวนเต็มสองจำนวนnและkเป็นอินพุทและเอาท์พุท / ส่งกลับค่าn th k - จำนวนเฉพาะสูงสุด นี่คือรหัสกอล์ฟดังนั้นโปรแกรมที่สั้นที่สุดในหน่วยไบต์ชนะ

กรณีทดสอบ

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

เบ็ดเตล็ด

คุณต้องสร้างช่วงเวลาด้วยตัวเองด้วยวิธีอื่นใดนอกจากแบบฟอร์มปิดง่าย ๆ ถ้าแบบฟอร์มปิดมีอยู่

Pyth, 9 ไบต์

e.fqlPZQE

คำอธิบาย

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

ลองที่นี่!

หรือลองชุดทดสอบ!

Brachylogขนาด 9 ไบต์

เอาชนะ @sundar โดยใช้ครึ่งไบต์มาก

{~l~ḋ}ᶠ⁽t

คำอธิบาย

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

ลองออนไลน์!

Pyke (กระทำ 29), 8 ไบต์ (ไม่ทำงาน)

.fPlQq)e

คำอธิบาย:

         - 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 ไบต์

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

นี่คือฟังก์ชันเรียกซ้ำที่ยอมรับจำนวนเต็มสองจำนวนและส่งกลับจำนวนเต็ม วิธีการที่นี่คือการตรวจสอบผลรวมของเลขชี้กำลังในการแยกตัวประกอบเฉพาะ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

เยลลี่ขนาด 9 ไบต์

ÆfL=³
ç#Ṫ

ลองออนไลน์!

มันทำงานอย่างไร

Ç#Ṫ    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 ไบต์

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

ลองออนไลน์!

                      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

Mathematica, 56 51 ไบต์

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

คำเตือน: นี่เป็นเชิงทฤษฎี ห้ามรันสำหรับค่าใด ๆ > 4 แทนที่ 2 ^ ## ด้วยนิพจน์ที่มีประสิทธิภาพมากขึ้น

Mathematica, 53 49 ไบต์

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

สร้างรายการจำนวนเต็มตามขอบเขตบนที่ว่าง PrimeOmegaนับจำนวนของไพรม์ที่มีหลายหลากk -almost ไพรม์Casesถูกนำมาจากรายการและสมาชิกลำดับที่nของเซ็ตย่อยนั้นจะถูกส่งคืน

Haskell, 88 ไบต์

อาจจะเล่นกอล์ฟได้มากขึ้นเพราะฉันยังเป็นมือใหม่กับ Haskell ฟังก์ชันqส่งคืนจำนวนปัจจัยของอาร์กิวเมนต์และfใช้เพื่อรับnthองค์ประกอบของรายการที่ทำจากตัวเลขทั้งหมดที่มีkปัจจัย

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 ไบต์

:YqiZ^!XpSu1G)

ลองใช้กับ 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 ไบต์

นี่เป็นฟังก์ชั่นบังคับเดรัจฉานที่ง่ายมาก มันจะตรวจสอบจำนวนเริ่มต้นจาก 2 ทุกsympyของfactorintฟังก์ชั่นจนกว่าจะได้พบn kเฉพาะ -almost จุดที่ฟังก์ชั่นส่งกลับnวันที่เหล่านี้

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:

ฉันใช้sum(factorint(a).values())เพราะfactorintคืนค่าพจนานุกรมของfactor: exponentคู่ โลภค่าของพจนานุกรม (เลขยกกำลัง) และข้อสรุปพวกเขาบอกฉันว่าหลายปัจจัยสำคัญที่มีและทำให้สิ่งkนี้kสำคัญ -almost คือ

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 ไบต์

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)

ลองออนไลน์!