Một số đánh giá cao hợp là một số nguyên dương có nhiều ước hơn bất kỳ số nguyên dương nhỏ hơn có. Đây là trình tự OEIS A002182 . 20 điều khoản đầu tiên của nó là

1, 2, 4, 6, 12, 24, 36, 48, 60, 120, 180, 240, 360, 720, 840, 1260, 1680, 2520, 5040, 7560

Ví dụ: 4nằm trong chuỗi vì nó có 3 ước (cụ thể là 1, 2, 4), trong khi 3 chỉ có 2 ước, 2 cũng có 2 ước và 1 có 1 ước.

Thử thách

Cho đầu vào số nguyên dương n , đầu ra là số hỗn hợp cao thứ n hoặc n số tổng hợp cao đầu tiên , theo lựa chọn của bạn (nhưng lựa chọn phải giống nhau cho mọi n đầu vào ).

Quy tắc

Về mặt lý thuyết, chương trình hoặc chức năng phải hoạt động đối với các đầu vào lớn tùy ý với thời gian và bộ nhớ vô hạn và không xem xét các giới hạn loại dữ liệu. Về cơ bản, điều này có nghĩa là không mã hóa số lượng giá trị hữu hạn.

Trong thực tế, chương trình hoặc chức năng nên chạy trong một khoảng thời gian hợp lý, giả sử dưới 1 phút, trong n tối đa 20. Đầu vào hoặc đầu ra tối đa có thể bị giới hạn bởi loại dữ liệu tiêu chuẩn ngôn ngữ của bạn (nhưng một lần nữa, thuật toán sẽ hoạt động theo lý thuyết cho số lượng lớn tùy ý).

Bất kỳ định dạng đầu vào và đầu ra hợp lý đều được cho phép, bao gồm cả unary.

Mã golf. Ít byte nhất sẽ thắng.

05AB1E , 15 14 byte

Các đầu vào trong không có chỉ mục. Điều đó có nghĩa là n = 0cho 1, n = 1cho 2, v.v. Mã:

$µ>DÑgD®›i©¼}\

Giải trình:

$               # Pushes 1 and input
 µ              # Counting loop, executes until the counting variable is equal to input
  >             # Increment (n + 1)
   DÑ           # Duplicate and calculate all divisors
     gD         # Get the length of the array and duplicate
       ®        # Retrieve element, standardized to zero
        ›i  }   # If greater than, do...
          ©     #   Copy value into the register
           ¼    #   Increment on the counting variable
             \  # Pop the last element in the stack

Tính n = 19 , sẽ cho 7560trong khoảng 10 giây.

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

Sử dụng mã hóa CP-1252 .

Thạch, 15 byte

,®ÆDL€ṛ©0>/?µƓ#

Đối với đầu vào n , điều này in ra n số tổng hợp đầu tiên .

Với n = 20 , chỉ mất chưa đến hai giây khi dùng thử trực tuyến!

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

,®ÆDL€ṛ©0>/?µƓ#  Main link. No implicit input.

            µ    Push the chain to the left on the local link stack.
             Ɠ   Read an integer n from STDIN.
              #  Execute the chain for k = 0, 1, 2, ..., until it returned a truthy
                 value n times. Return the list of matches.

,®               Pair k with the value in the register (initially 0).
  ÆD             Compute the divisors of k and the register value.
    L€           Count both lists of divisors.
           ?     If
         >/        k has more divisors than the register value:
      ṛ©             Save k in the register and return k.
        0          Else: Return 0.

Phiên bản thay thế, 13 byte (không cạnh tranh)

Mặc dù đoạn mã dưới đây hoạt động trong phiên bản mới nhất của Jelly trước thử thách này, việc triển khai Mrất chậm và nó không tuân thủ giới hạn thời gian. Điều này đã được sửa chữa.

ÆDL®;©MḢ’>µƓ#

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

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

ÆDL®;©MḢ’>µƓ#  Main link. No implicit input.

          µ    Push the chain to the left on the local link stack.
           Ɠ   Read an integer n from STDIN.
            #  Execute the chain for k = 0, 1, 2, ..., until it returned a truthy
               value n times. Return the list of matches.

ÆD             Compute the divisors of k.
  L            Count them.
   ®;          Append the count to the list in the register (initially 0 / [0]).
     ©         Save the updated list in the register.
      M        Obtain all indices the correspond to maximal elements.
       Ḣ       Retrieve the first result.
        ’>     Subtract 1 and compare with k.
               This essentially checks if the first maximal index is k + 2, where
               the "plus 2" accounts for two leading zeroes (initial value of the
               register and result for k = 0).

MATL , 26 24 byte

~XKx`K@@:\~s<?@5MXKx]NG<

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

Số lượng ước số lớn nhất hiện tại được tìm thấy được giữ trong clipboard K. Các số tổng hợp cao (HCN) được giữ trực tiếp trên ngăn xếp. Một vòng lặp giữ các thí sinh kiểm tra HCN. Khi tìm thấy nó, nó được để lại trên ngăn xếp và clipboard K được cập nhật. Vòng lặp thoát khi tìm thấy số lượng HCN mong muốn.

~         % take input implicitly (gets stored in clipboard G). Transform into a 0 
          % by means of logical negation
XKx       % copy that 0 into clipboard K, and delete
`         % do...while
  K       %   push largest number of divisors found up to now
  @       %   push iteration index, i: current candidate to HCN
  @:      %   range [1,...,i]
  \       %   modulo operation
  ~s      %   number of zeros. This is the number of divisors of current candidate
  <       %   is it larger than previous largest number of divisors?
  ?       %   if so: a new HCN has been found
    @     %     push that number
    5M    %     push the number of divisors that was found
    XKx   %     update clipboard K, and delete
  ]       %   end if
  N       %   number of elements in stack
  G<      %   is it less than input? This the loop condition: exit when false
          % end do...while implicitly
          % display all numbers implicitly

Perl, 60 57 + 1 = 58 byte

$,++;$==grep$,%$_<1,1..$,;$_--,$m=$=if$=>$m;$_?redo:say$,

Yêu cầu -nvà miễn phí -M5.010| -E:

$ perl -nE'$,++;$==grep$,%$_<1,1..$,;$_--,$m=$=if$=>$m;$_?redo:say$,' <<< 10 
120

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

$,++;
     $==grep$,%$_<1,1..$,;                                # Calculate total numbers of divisors for `$,`
                          $_--,$m=$=if$=>$m;              # Set `$m`ax divisors to `$=`ivisors if `$m>$=`
                                            $_?redo:say$, # Repeat or print

JavaScript (ES6) 72

Thực hiện đơn giản. Thời gian gần 20 giây cho đầu vào 20

x=>{for(i=e=n=0;i<x;d>e&&(++i,e=d))for(d=1,j=++n;--j;)n%j||++d;return n}

Thủ thuật eval có thể tiết kiệm một byte nhân đôi thời gian chạy

x=>eval("for(i=e=n=0;i<x;d>e&&(++i,e=d))for(d=1,j=++n;--j;)n%j||++d;n")

Ít chơi gôn

x=>{
  for(i = e = 0, n = 1; i < x; n++)
  {
    for(d = 1, j = n; --j; )
    {
      if (n%j == 0) 
        ++d;
    }
    if (d > e)
      ++i,
      e = d;
  }
  return n;
}

Bình thường, 17 16 byte

1 byte nhờ Jakube

uf<Fml{yPd,GTGQ1

Bộ kiểm tra

Lấy n chỉ số 0 và trả về số tổng hợp cao thứ n .

Giải trình:

uf<Fml{yPd,GThGQ1
                     Input: Q = eval(input())
u              Q1    Apply the following function Q times, starting with 1.
                     Then output the result. lambda G.
 f           hG      Count up from G+1 until the following is truthy, lambda T.
          ,GT        Start with [G, T] (current highly comp., next number).
    m                Map over those two, lambda d.
        Pd           Take the prime factorization of d, with multiplicity.
       y             Take all subsets of those primes.
      {              Deduplicate. At this point, we have a list of lists of primes.
                     Each list is the prime factorization of a different factor.
     l               Take the length, the number of factors.
  <F                 Check whether the number of factors of the previous highly
                     composite number is smaller than that of the current number.

Hồng ngọc, 70 69 67 66 64 62

->n{r=k=0
0until(r<t=(1..k+=1).count{|d|k%d<1})&&1>n-=t/r=t
k}

Thực hiện đơn giản.

C, 98 byte

f,i,n,j;main(m){for(scanf("%d",&n);n--;printf("%d ",i))for(m=f;f<=m;)for(j=++i,f=0;j;)i%j--||f++;}

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

Bị đánh cắp

f,i,n,j;

main(m)
{
    for(scanf("%d",&n); /* Get input */
            n--; /* Loop while still HCN's to calculate... */
            printf("%d ",i)) /* Print out the last calculated HCN */
        for(m=f;f<=m;) /* Loop until an HCN is found... */
            for(j=++i,f=0;j;) /* Count the number of factors */
                i%j--||f++;
}

Python 3, 97 byte

i=p=q=0;n=int(input())
while q<n:
 c=j=0;i+=1
 while j<i:j+=1;c+=i%j==0
 if c>p:p=c;q+=1
print(i)

Một chương trình đầy đủ lấy đầu vào từ STDIN và in đầu ra thành STDOUT. Điều này trả về nsố tổng hợp cao thứ 1 được lập chỉ mục.

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

Đây là một thực hiện đơn giản. Đầu vàon là chỉ số số tổng hợp cao.

Chương trình lặp lại qua các số nguyên i. Đối với mỗi số nguyên jnhỏ hơn i, i mod jđược lấy; nếu điều này là 0, jphải là một yếu tố ivà bộ đếm cđược tăng lên, đưa ra số lượng ước của isau khi lặp. plà số ước số cao nhất trước đó, vì vậy, nếu c > p, một số tổng hợp cao mới đã được tìm thấy và bộ đếm qđược tăng lên. Một lần q = n, iphải là nsố tổng hợp cao thứ, và điều này được in.

Hãy thử nó trên Ideone

(Thời gian này mất ~ 15 giây n = 20, vượt quá giới hạn thời gian cho Ideone. Do đó, ví dụ đưa ra là dành cho n = 18.)

Python 2, 207 byte

n,i,r,o=input(),1,[],[]
while len(o)<n:
 r+=[(lambda n:len(set(reduce(list.__add__,([i,n//i]for i in range(1,int(n**0.5)+1)if n%i==0)))))(i)];h=max(r)
 if r.index(h)>i-2 and r.count(h)<2:o+=[i]
 i+=1
print o

Sử dụng phương pháp tương tự như câu trả lời của Dennis 'Jelly. Tính 20 điều khoản đầu tiên trong <2vài giây.