Angka yang sangat komposit adalah bilangan bulat positif yang memiliki lebih banyak pembagi daripada bilangan bulat positif yang lebih kecil. Ini adalah urutan OEIS A002182 . 20 istilah pertamanya adalah

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

Misalnya, 4ada dalam urutan karena memiliki 3 pembagi (yaitu 1, 2, 4), sedangkan 3 hanya memiliki 2 pembagi, 2 juga memiliki 2 pembagi, dan 1 memiliki 1 pembagi.

Tantangan

Diberikan input bilangan bulat positif n , hasilkan bilangan yang sangat komposit n -th atau bilangan yang sangat komposit n pertama , sesuai pilihan Anda (tetapi pilihan harus sama untuk setiap input n ).

Aturan

Program atau fungsi harus secara teoritis bekerja untuk input besar sembarang yang diberikan waktu dan memori tak terbatas, dan tanpa mempertimbangkan batasan tipe data. Pada dasarnya, ini berarti tidak ada hardcoding sejumlah nilai yang terbatas.

Dalam praktiknya, program atau fungsi harus berjalan dalam jumlah waktu yang wajar, katakanlah kurang dari 1 menit, untuk n hingga 20. Input atau output maksimum mungkin dibatasi oleh tipe data standar bahasa Anda (tetapi sekali lagi, algoritme harus secara teoritis bekerja untuk jumlah besar yang sewenang-wenang).

Setiap input dan format output yang masuk akal diizinkan, termasuk unary.

Golf kode. Bytes paling sedikit menang.

05AB1E , 15 14 byte

Masukan dalam indeks-nol. Itu berarti n = 0memberi 1, n = 1memberi 2, dll. Kode:

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

Penjelasan:

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

Menghitung n = 19 , yang akan menghasilkan 7560sekitar 10 detik.

Cobalah online!

Menggunakan pengodean CP-1252 .

Jelly, 15 byte

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

Untuk input n , ini mencetak angka pertama n yang sangat komposit.

Untuk n = 20 , dibutuhkan kurang dari dua detik di Coba online!

Bagaimana itu bekerja

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

Versi alternatif, 13 byte (tidak bersaing)

Sementara kode di bawah ini berfungsi dalam versi terbaru Jelly yang mendahului tantangan ini, implementasinya Msangat lambat, dan tidak sesuai dengan batas waktu. Ini sudah diperbaiki.

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

Cobalah online!

Bagaimana itu bekerja

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

Cobalah online!

Jumlah pembagi terbesar yang ditemukan saat ini disimpan di clipboard K. Nomor yang sangat komposit (HCN) disimpan langsung di tumpukan. Sebuah loop terus menguji kandidat ke HCN. Ketika satu ditemukan itu ditinggalkan di tumpukan, dan clipboard K diperbarui. Loop keluar ketika jumlah HCN yang diinginkan telah ditemukan.

~         % 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$,

Membutuhkan -ndan gratis -M5.010| -E:

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

Bagaimana itu bekerja:

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

Implementasi langsung. Waktu hampir 20 detik untuk input 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}

Trik eval bisa menghemat byte dua kali lipat waktu berjalan

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

Kurang golf

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 byte

1 byte berkat Jakube

uf<Fml{yPd,GTGQ1

Suite uji

Mengambil 0 diindeks n , dan mengembalikan n sangat komposit.

Penjelasan:

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.

Ruby, 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}

Implementasi langsung.

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

Coba di sini .

Tidak disatukan

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)

Program lengkap yang mengambil input dari STDIN dan mencetak output ke STDOUT. Ini mengembalikan nnomor komposit sangat terindeks th 1.

Bagaimana itu bekerja

Ini adalah implementasi yang mudah. Input nadalah indeks angka yang sangat komposit.

Program ini mengulangi bilangan bulat i. Untuk setiap bilangan bulat jkurang dari i, i mod jdiambil; jika ini 0, jharus menjadi faktor idan penghitung cbertambah, memberikan jumlah pembagi isetelah pengulangan. padalah jumlah pembagi tertinggi sebelumnya, jadi jika c > p, angka baru yang sangat komposit telah ditemukan dan penghitung qbertambah. Sekali q = n, ipasti nomor yang nsangat komposit, dan ini dicetak.

Cobalah di Ideone

(Ini membutuhkan ~ 15 detik untuk n = 20, yang melebihi batas waktu untuk Ideone. Karenanya, contoh yang diberikan adalah untuk 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

Menggunakan metode yang sama dengan jawaban Dennis 'Jelly. Hitung 20 istilah pertama dalam <2detik.