Yüksek oranda bileşik , daha küçük pozitif bir tamsayıdan daha fazla bölene sahip pozitif bir tam sayıdır. Bu, OEIS dizisi A002182'dir . İlk 20 terimi

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

Örneğin 4, sırada 3 bölücü (yani 1, 2, 4), 3'te sadece 2 bölücü, 2'de 2 bölücü ve 1'de 1 bölücü var.

Meydan okuma

Pozitif tam giriş Verilen n , çıkış ya n yüksek bileşik sayı ya da ilk oyunu bırakanların n yüksek kompozit sayılar, seçtiğiniz en (ancak seçim her giriş için aynı olmalıdır n ).

kurallar

Program veya işlev teorik olarak, sınırsız zaman ve bellek verilen ve isteğe bağlı olarak büyük veri girişleri için ve veri tipi sınırlamaları göz önüne alınmadan çalışmalıdır. Temel olarak bu, sınırlı sayıda değerin kodlanmaması anlamına gelir.

Uygulamada, program veya işlev makul bir süre içerisinde, 1 dakikadan az, n için 20'ye kadar süre ile çalışmalıdır. keyfi büyük sayılar için).

Unary de dahil olmak üzere herhangi bir makul giriş ve çıkış formatına izin verilir.

Kod golfü. En az bayt kazanır.

05AB1E , 15 14 bayt

Sıfır dizinli giriş. Bu, n = 0verir 1, n = 1verir 2vb anlamına gelir . Kod:

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

Açıklama:

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

Yaklaşık 10 saniye içinde verilmesi gereken n = 19 değerini hesaplar 7560.

Çevrimiçi deneyin!

CP-1252 kodlamasını kullanır .

Jöle, 15 bayt

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

N girişi için bu, ilk n yüksek bileşik sayılarını yazdırır .

İçin n = 20 , bu daha az bir iki saniye sürer çevrimiçi deneyin!

Nasıl çalışır

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

Alternatif sürüm, 13 bayt (yarışmaz)

Aşağıdaki kod, bu zorluktan önceki Jelly sürümünde çalışırken, uygulanması Mçok yavaştı ve zaman sınırına uymadı. Bu giderildi.

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

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Çevrimiçi deneyin!

Bulunan en büyük bölen sayısı panoda K tutulur. Çok sayıda kompozit sayı (HCN) doğrudan yığında tutulur. Bir döngü HCN'ye adayları test etmeye devam ediyor. Bir tane bulunduğunda yığında bırakılır ve pano K güncellenir. İstenilen HCN sayısı bulunduğunda döngü çıkar.

~         % 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 bayt

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

Gerektirir -nve ücretsiz -M5.010| -E:

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

Nasıl çalışır:

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

Basit uygulama. Giriş 20 için 20 saniye civarında süre

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

Değerlendirme numarası, çalışma zamanını iki katına çıkararak bir bayt kurtarabilir

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

Daha az golf oynadı

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 bayt

Jakube sayesinde 1 bayt

uf<Fml{yPd,GTGQ1

Test odası

0 indeksli bir n alır ve nth yüksek bileşik sayısını döndürür .

Açıklama:

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}

Basit uygulama.

C, 98 bayt

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

Burada dene .

Ungolfed

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 bayt

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'den girdi alan ve çıktıyı STDOUT'a basan tam bir program. Bu, n1 indeksli yüksek bileşik sayısını döndürür .

Nasıl çalışır

Bu basit bir uygulamadır. Girdin , yüksek bileşik sayı endeksidir.

Program tamsayılar üzerinde yinelenir i. Her tamsayı için jdaha az i, i mod jalınır; eğer öyleyse 0, jbir faktör olmalı ive sayaç carttırılır, idöngü sonrası bölenlerin sayısını verir . pönceki en yüksek bölen sayısıdır, öyleyse c > p, yeni bir yüksek bileşik sayı bulundu ve sayaç qartırıldı. Bir kez q = n,in yüksek bileşik sayı olmalıdır ve bu yazdırılır.

Ideone'da dene

(Bu n = 20Ideone için zaman sınırını aşan için ~ 15 saniye sürer . Dolayısıyla, verilen örnek içindir n = 18.)

Python 2,207 bayt

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'in Jelly cevabı ile aynı yöntemi kullanır. İlk 20 terimi <2saniye cinsinden hesaplar .