Argthtjtr

I'm seeking an efficient implementation of the number-theoretic function giving the smallest integer $n$ that has exactly $k$ factors (not necessarily prime):

f[k_Integer]:= ...

• 
  f[1] = 1 because $1$ is the smallest integer that has just a single factor, i.e., ${ 1 }$
  


• 
  f[2] = 2 because $2$ is the smallest integer that has just the two factors, i.e., ${ 1, 2 }$
  


• 
  f[3] = 4 because $4$ is the smallest integer that has exactly three factors, i.e., ${ 1, 2, 4 }$
  


• 
  f[4] = 6 because $6$ is the smallest integer that has exactly four factors, i.e., ${ 1, 2, 3, 6 }$
  


• 
  f[5] = 16 because $16$ is the smallest integer that has exactly five factors, i.e., ${ 1, 2, 4, 8, 16 }$
  


• 
  f[6] = 12 because $12$ is the smallest integer that has exactly six factors, i.e., ${ 1, 2, 3, 4, 6, 12 }$
  


• 
  f[7] = 64 because $64$ is the smallest integer that has exactly seven factors, i.e., ${ 1, 2, 4, 8, 16, 32, 64 }$
  


• 
  f[8] = 24 because $24$ is the smallest integer that has exactly eight factors, i.e., ${ 1, 2, 3, 4, 6, 8, 12, 24 }$
  


• 
  f[9] = 36 because $36$ is the smallest integer that has exactly nine factors, i.e., ${ 1, 2, 3, 4, 6, 9, 12, 18, 36 }$
  

A few moments of thought will show that for $k$ odd, $n$ is a perfect square. Moreover, note that f[k] is not monotonic.

Very inefficient code would advance through increasing $n$ until an integer is found with the criterion of exactly $k$ factors, but this is extremely inefficient for large $k$.

This generates the pairs $n,k$ up to $n=100$:

myList = Table[{n, Times @@ (# + 1 & /@ FactorInteger[n][[All, 2]])}, 

  {n, 2, 100}]

And it is a simple matter to select cases with a given $k$:

Select[myList, #[[2]] == 60]

When $k sim 10^6$, this is somewhat slow and definitely memory intensive.

As background/edification, here is a log plot of $n$ versus $k$.

In 1644, the great mathematician Mersenne asked for f[60] = 5040.

Note that the divisor count function of a number with prime factorization $$n=p_1^{a_1} p_2^{a_2} cdots p_i^{a_i}$$ satisfies:
$$tau (n)=prod _k^i left(a_k+1right)$$

So, to find an inverse of the divisor count function, we need to find a
number whose prime factorization is equal to the right hand side, from which we can determine what the values of $a_k$ must be. Here is a function that does this:

InverseDivisor[n_] := With[

    {f = Reverse[Join @@ ConstantArray @@@ FactorInteger[n] -1]},

    Times @@ ((Prime @ Range @ Length @ f)^f)

]

Some more work is needed to make sure the inverse returned is the minimum. For example, my simple minded algorithm gives 30 instead of 24 for the inverse of 8. Let's check your examples:

i = InverseDivisor /@ Range[9]

{1, 2, 4, 6, 16, 12, 64, 30, 36}

And let's check your harder version:

InverseDivisor[60]

5040

Next, let's see how long it takes to do $10^6$:

big = InverseDivisor[10^6]; //AbsoluteTiming

big

{0.000059, Null}

200961610708938459249870000

Finally, we can check the above results by using DivisorSigma:

DivisorSigma[0, i]

DivisorSigma[0, 5040]

DivisorSigma[0, big]

{1, 2, 3, 4, 5, 6, 7, 8, 9}

60

1000000

If a number $n$ has $k$ divisors, then $k=(a_1+1)(a_2+1)ldots (a_m+1)$, where the prime factorisation of $n=p_1^{a_1} p_2^{a_2}ldots p_m^{a_m}$, as @CarlWoll points out. Therefore, $k$ must be the product of $m$ factors, each $ge2$.

The general problem of multiplicative partitions is discussed on Stack Exchange here and here. Adapting code from the article by Knopfmacher and Mays gives the following function MultiplicativePartitions[n].

MultiplicativePartitions[1, m_] := {{}}

MultiplicativePartitions[n_, 1] := {{}}

MultiplicativePartitions[n_?PrimeQ, m_] := If[m < n, {}, {{n}}]



MultiplicativePartitions[n_, m_] :=     

   Join @@ Table[

              Map[Prepend[#, d] &, MultiplicativePartitions[n/d, d]],

              {d, Select[Rest[Divisors[n]], # <= m &]}]



MultiplicativePartitions[n_] := MultiplicativePartitions[n, n]

For example,

 MultiplicativePartitions[24]

{{3, 2, 2, 2}, {4, 3, 2}, {6, 2, 2}, {6, 4}, {8, 3}, {12, 2}, {24}}

Thus,

MinWithDivisors[k_] :=    

   Min[Map[Times @@ (Prime[Range[Length[#]]]^(# - 1)) &, 

           MultiplicativePartitions[k]]]



SetAttributes[MinWithDivisors, Listable]

A quick test:

MinWithDivisors[Range[20]]

{1, 2, 4, 6, 16, 12, 64, 24, 36, 48, 1024, 60, 4096, 192, 144, 120,
65536, 180, 262144, 240}

The function MinWithDivisors[k] agrees with a brute-force search.

Block[{t = DivisorSigma[0, Range[300000]]},

   Table[FirstPosition[t, k, {0}][[1]], {k, 1, 20}]

]

The solution for one million divisors, $k=10^6$, is the following.

AbsoluteTiming[MinWithDivisors[10^6]]

{0.077611, 173804636288811640432320000}

Note that this result is less than that given by InverseDivisor defined by Carl, who correctly warned that "more work" was required.