Un numero altamente composito è un numero intero positivo che ha più divisori di qualsiasi numero intero più piccolo positivo. Questa è la sequenza OEIS A002182 . I suoi primi 20 termini sono

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

Ad esempio, 4è nella sequenza perché ha 3 divisori (ovvero 1, 2, 4), mentre 3 ha solo 2 divisori, 2 ha anche 2 divisori e 1 ha 1 divisori.

Sfida

Dato un input intero positivo n , emettere l' n -esimo numero altamente composito o i primi n numeri altamente compositi, a propria scelta (ma la scelta deve essere la stessa per ogni input n ).

Regole

Il programma o la funzione dovrebbero teoricamente funzionare per input arbitrariamente grandi dati con tempo e memoria infiniti e senza considerare le limitazioni del tipo di dati. In sostanza, ciò significa che non è possibile codificare in modo rigido un numero finito di valori.

In pratica, il programma o la funzione dovrebbero essere eseguiti in un tempo ragionevole, diciamo meno di 1 minuto, per n fino a 20. Il massimo input o output può essere limitato dal tipo di dati standard della tua lingua (ma, di nuovo, l'algoritmo dovrebbe teoricamente funzionare per numeri arbitrariamente grandi).

È consentito qualsiasi formato di input e output ragionevole, incluso unario.

Codice golf. Vince il minor numero di byte.

05AB1E , 15 14 byte

L'input è indicizzato a zero. Ciò significa che n = 0dà 1, n = 1dà 2, ecc. Codice:

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

Spiegazione:

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

Calcola n = 19 , che dovrebbe dare 7560in circa 10 secondi.

Provalo online!

Utilizza la codifica CP-1252 .

Gelatina, 15 byte

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

Per l'ingresso n , questo stampa i primi n numeri altamente compositi.

Per n = 20 , ci vogliono meno di due secondi su Provalo online!

Come funziona

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

Versione alternativa, 13 byte (non competitiva)

Mentre il codice seguente ha funzionato nell'ultima versione di Jelly che precede questa sfida, l'implementazione di è Mstata molto lenta e non ha rispettato il limite di tempo. Questo è stato risolto.

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

Provalo online!

Come funziona

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

Provalo online!

L'attuale maggior numero di divisori trovati è conservato negli appunti K. I numeri altamente compositi (HCN) vengono mantenuti direttamente nello stack. Un ciclo continua a testare i candidati all'HCN. Quando ne viene trovato uno, questo viene lasciato in pila e gli Appunti K vengono aggiornati. Il loop termina quando viene trovato il numero desiderato di 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 byte

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

Richiede -ne il libero -M5.010| -E:

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

Come funziona:

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

Implementazione semplice. Tempo vicino a 20 secondi per l'ingresso 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}

Il trucco di valutazione potrebbe salvare un byte raddoppiando il tempo di esecuzione

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

Meno 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 grazie a Jakube

uf<Fml{yPd,GTGQ1

Suite di test

Prende un n indicizzato 0 e restituisce l' ennesimo numero altamente composito.

Spiegazione:

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.

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

Implementazione semplice.

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

Provalo qui .

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

Un programma completo che accetta input da STDIN e stampa l'output su STDOUT. Ciò restituisce il nnumero altamente composito con 1 indice.

Come funziona

Questa è un'implementazione semplice. L'input nè l'indice numerico altamente composito.

Il programma scorre sopra gli interi i. Per ogni numero intero jinferiore a i, i mod jviene preso; in questo caso 0, jdeve essere un fattore di ie il contatore cviene incrementato, fornendo il numero di divisori di iafter looping. pè il precedente numero più alto di divisori, quindi se c > pè stato trovato un nuovo numero altamente composito e il contatore qviene incrementato. Una volta q = n, ideve essere il nnumero altamente composito e questo viene stampato.

Provalo su Ideone

(Ciò richiede ~ 15 secondi per n = 20, che supera il limite di tempo per Ideone. Quindi, l'esempio fornito è per 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

Utilizza lo stesso metodo della risposta Jelly di Dennis. Calcola i primi 20 termini in <2secondi.