甲高合成数是具有多个除数比任何小的正整数具有一个正整数。这是OEIS序列A002182。它的前20个学期是

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

例如，4由于序列中有3个除数（即1、2、4），而3中只有2个除数，所以2也具有2个除数，而1具有1个除数。

挑战

给定正整数输入n，根据您的选择输出第n个高复合数或前n个高复合数（但每个输入n的选择必须相同）。

规则

程序或函数在理论上应该在给定无限时间和内存的情况下用于任意大的输入，而不考虑数据类型的限制。本质上，这意味着无需对有限数量的值进行硬编码。

在实践中，程序或函数应在合理的时间内运行，例如少于1分钟，最多n到20。最大输入或输出可能受您的语言标准数据类型的限制（但同样，算法在理论上应该可以工作对于任意大数）。

允许使用任何合理的输入和输出格式，包括一元。

代码高尔夫。最少的字节数获胜。

05AB1E，15 14字节

输入为零索引。那意味着n = 0给1，n = 1给2，等等。代码：

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

说明：

$               # 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

计算n = 19，应7560在大约10秒内给出。

在线尝试！

使用CP-1252编码。

果冻，15个字节

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

对于输入n，这将打印前n个高度复合的数字。

对于n = 20，只需不到两秒钟即可在线尝试！

怎么运行的

,®Æ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.

备用版本，13字节（无​​竞争）

尽管以下代码在此挑战之前的最新版本的Jelly中M可用，但是的实现非常缓慢，并且不符合时间限制。此问题已解决。

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

在线尝试！

怎么运行的

Æ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字节

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

在线尝试！

当前找到的最大除数保留在剪贴板K中。高度复合数（HCN）直接保留在堆栈中。循环使测试候选人成为HCN。找到一个后，将其保留在堆栈中，并更新剪贴板K。找到所需数量的HCN后，循环退出。

~         % 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字节

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

需要-n和免费-M5.010| -E：

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

怎么运行的：

$,++;
     $==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

简单实施。输入20的时间接近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}

评估技巧可以节省一个字节，使运行时间加倍

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

Pyth，17 16字节

1字节感谢Jakube

uf<Fml{yPd,GTGQ1

测试套件

接受一个0索引的n，并返回第n个高度复合数。

说明：

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.

红宝石，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}

简单实施。

C，98字节

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++;}

在这里尝试。

不打高尔夫球

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个字节

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)

完整程序，可从STDIN接收输入并将输出打印到STDOUT。这将返回n第1个索引的高度组合数。

怎么运行的

这是一个简单的实现。输入n是高度复合数字索引。

该程序遍历整数i。对于j小于的每个整数i，i mod j采用；如果为0，则j必须为的一个因数，i并且计数器c会增加，从而得出iafter循环的除数。p是先前最大的除数数，因此，如果存在c > p，则找到一个新的高度复合数并且计数器q递增。一旦q = n，i必须是n第一个高度综合的数字，并且此数字被打印出来。

在Ideone上尝试

（这需要大约15秒n = 20的时间，超过了Ideone的时间限制。因此，给出的示例是针对的n = 18。）

Python 2，207字节

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

使用与丹尼斯的果冻答案相同的方法。以<2秒为单位计算前20个字词。