Um número altamente composto é um número inteiro positivo que possui mais divisores do que qualquer número inteiro positivo menor. Esta é a sequência O00E A002182 . Seus primeiros 20 termos são

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

Por exemplo, 4está na sequência porque possui 3 divisores (1, 2, 4), enquanto 3 possui apenas 2 divisores, 2 também possui 2 divisores e 1 possui 1 divisores.

Desafio

Dada uma entrada inteira positiva n , imprima o n- ésimo número altamente composto ou o primeiro n número altamente composto, à sua escolha (mas a escolha deve ser a mesma para cada entrada n ).

Regras

O programa ou função deve, teoricamente, trabalhar para entradas arbitrariamente grandes, com tempo e memória infinitos, e sem considerar as limitações do tipo de dados. Essencialmente, isso significa que não é necessário codificar um número finito de valores.

Na prática, o programa ou função deve ser executado em um período de tempo razoável, digamos menos de 1 minuto, por n até 20. A entrada ou saída máxima pode ser limitada pelo tipo de dados padrão do seu idioma (mas, novamente, teoricamente, o algoritmo deve funcionar para números arbitrariamente grandes).

Qualquer formato de entrada e saída razoável é permitido, inclusive unário.

Código de golfe. Menos bytes ganha.

05AB1E , 15 14 bytes

A entrada é indexada a zero. Isso significa que n = 0dá 1, n = 1dá 2, etc. Código:

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

Explicação:

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

Calcula n = 19 , que deve dar 7560em cerca de 10 segundos.

Experimente online!

Usa a codificação CP-1252 .

Gelatina, 15 bytes

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

Para a entrada n , imprime os primeiros n números altamente compostos.

Para n = 20 , leva menos de dois segundos em Experimente online!

Como funciona

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

Versão alternativa, 13 bytes (não concorrente)

Enquanto o código abaixo funcionava na versão mais recente do Jelly que precede esse desafio, a implementação de Mera muito lenta e não estava em conformidade com o prazo. Isso foi corrigido.

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

Experimente online!

Como funciona

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

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

Experimente online!

O maior número atual de divisores encontrados é mantido na área de transferência K. Os números altamente compostos (HCN) são mantidos diretamente na pilha. Um loop mantém o teste de candidatos à HCN. Quando um é encontrado, ele é deixado na pilha e a área de transferência K é atualizada. O loop termina quando o número desejado de HCN foi encontrado.

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

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

Requer -ne grátis -M5.010| -E:

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

Como funciona:

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

Implementação direta. Tempo próximo a 20 s para a entrada 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}

O truque eval poderia salvar um byte dobrando o tempo de execução

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

Menos golfe

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

Pitão, 17 16 bytes

1 byte graças a Jakube

uf<Fml{yPd,GTGQ1

Suíte de teste

Pega um n indexado a 0 e retorna o enésimo número altamente composto.

Explicação:

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}

Implementação direta.

C, 98 bytes

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

Experimente aqui .

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 bytes

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)

Um programa completo que recebe a entrada de STDIN e imprime a saída em STDOUT. Isso retorna o nnúmero altamente composto composto de 1 índice.

Como funciona

Esta é uma implementação direta. A entrada né o índice numérico altamente composto.

O programa itera sobre os números inteiros i. Para cada número inteiro jmenor que i, i mod jé obtido; se for 0, jdeve ser um fator de ie o contador cé incrementado, fornecendo o número de divisores dei após o loop. pé o número mais alto anterior de divisores; portanto, se c > pum novo número altamente composto for encontrado e o contador qfor incrementado. Uma vez q = n, ideve ser o nth número altamente composto, e isso é impresso.

Experimente no Ideone

(Isso leva aproximadamente 15 segundos para n = 20, o que excede o limite de tempo para Ideone. Portanto, o exemplo fornecido é paran = 18 .)

Python 2, 207 bytes

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

Usa o mesmo método da resposta de Dennis 'Jelly. Calcula os primeiros 20 termos em <2segundos.