매우 합성 수는 임의의 작은 양의 정수 약수 가지고 이상을 갖는 양의 정수이다. 이다 OEIS 순서 A002182 . 처음 20 개의 용어는

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

예를 들어, 43 개의 제수 (즉, 1, 2, 4)가있는 반면, 3은 2의 제수 만 있고 2는 2의 제수도 있고 1은 1의 제수를 가지고 있기 때문에 시퀀스에 있습니다.

도전

양의 정수 입력 n이 주어지면 원하는 대로 n 번째 복합 숫자 또는 첫 번째 n 복합 숫자를 출력하십시오 (그러나 선택은 모든 입력 n에 대해 동일해야 함 ).

규칙

프로그램이나 함수는 이론적으로 데이터 유형 제한을 고려하지 않고 무한한 시간과 메모리가 주어지면 임의로 큰 입력에 대해 작동해야합니다. 본질적으로 이것은 유한 한 수의 값을 하드 코딩하지 않음을 의미합니다.

실제로, 프로그램 또는 함수는 n 까지 최대 20 분 동안 적당한 시간, 즉 1 분 미만으로 실행해야합니다 . 최대 입력 또는 출력은 언어 표준 데이터 유형에 따라 제한 될 수 있습니다 (그러나 알고리즘은 이론적으로 작동해야합니다) 임의로 많은 수의 경우).

단항을 포함하여 모든 합리적인 입력 및 출력 형식이 허용됩니다.

코드 골프. 가장 적은 바이트가 이깁니다.

05AB1E , 15 14 바이트

인덱스가 0 인 입력입니다. 즉 , n = 0give 1, n = 1gives 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

약 10 초 안에 n = 19를 계산 합니다 7560.

온라인으로 사용해보십시오!

CP-1252 인코딩을 사용합니다 .

젤리, 15 바이트

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

입력 n의 경우 처음 n을 인쇄합니다 복합 숫자를 .

를 들어 N = 20 , 그것은에 2 초 미만 소요 온라인 체험을!

작동 원리

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

펄, 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

자바 스크립트 (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;
}

피 이스, 17 16 바이트

Jakube 덕분에 1 바이트

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

파이썬 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으로 인쇄하는 전체 프로그램. 이것은 n1- 인덱싱 된 복합 숫자를 반환합니다 .

작동 원리

이것은 간단한 구현입니다. 입력 값 n은 복합 숫자 인덱스입니다.

프로그램은 정수를 반복합니다 i. 각 정수 j미만 i, i mod j촬영; 이 경우 0, j의 요인이 될 수 있어야 i하고, 카운터 c의 약수의 개수를 제공, 증가 i루프 후. p는 이전에 가장 큰 제수의 수이므로이면 c > p새로운 복합 수가 발견되고 카운터 q가 증가합니다. 일단 q = n, i해야합니다 n번째 높은 복합 번호,이 인쇄됩니다.

Ideone에서 사용해보십시오

(이것은 ~ 15 초가 걸리며 이는 n = 20Ideone의 시간 제한을 초과합니다. 따라서 주어진 예는입니다 n = 18.)

파이썬 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

Dennis 'Jelly 답변과 동일한 방법을 사용합니다. 처음 20 개의 항을 <2초 단위로 계산합니다 .