Live data from Hacker News

How big are factorials?

eli.thegreenplace.net

11–20 of 42 posts

Re: How big are factorials?

#11
post #6

A quick and dirty approximation of the number of digits in n! is n lg n, which approximates n! from above, via the inequality 1 * 2 * … * n ≤ n * … * n. (This approximation should be familiar to many from an algorithmics class.) For a tighter bound, use n lg n - n/2, or a better approximation of ln 10 in place of 1/2 if you wish. This comes from Stirling's approximation which notes that ln n! = n ln n - n + O(ln n).

> (This approximation should be familiar to many from an algorithmics class.)

You need both sides though :)

What makes it interesting for estimating algorithmic complexity is that \log{n!} \in \Theta(n \log n). One side is obvious as you note, the other less so, but there's a famous trick to do both at once:

\log{n!} = \log{\prod_{h=0}^{n} h} = \sum_{h=0}^{n} \log{h}

Therefore,

\int_0^n \log{x} dx \le \log{n!} \le \int_0^n \log{x+1} dx

with both integrals trivial by parts.

Re: How big are factorials?

#12
post #8
post #3

Reminds me of: Professor asked us to find the biggest factorial using C programming language. And then using LISP. You can imagine our surprise.

There is a algorithm call Prime Swing Factorial that can compute large factorials exactly in arbitrary precision math using prime factorization. Like 10000000! in under second depending of how optimized the math library it. Probably like 100x faster than the normal method.

Worth noting for anyone reaching for this in practice rather than out of curiosity: several standard library implementations (Python's math.factorial is one) already use a divide-and-conquer multiplication scheme instead of naive sequential multiplication for exactly this reason, so you often get most of that speedup for free without implementing prime swing yourself.

Re: How big are factorials?

#13
lg(n!) grows roughly as (n lg n). Constants matter, of course, but to that's the rough estimate.

As an aside, if you take numbers from 0 to (n-1) in an array, there are n! configurations, so representing each configuration or differentiating each configuration take n lg n bits. So, in some sense, taking a mapping that's able to differentiate the input state to map to the ordered state takes at least O(n lg n) time, the standard runtime of a basic sorting algorithm.

Any additional assumptions (n larger than maximum element, distribution of elements) helps reduce this.

Re: How big are factorials?

#14
post #5

The author's casual mention of 52! at the opening of the article triggered an OLD webpage that I saw many years ago https://czep.net/weblog/52cards.html Anyone know how to determine the age of this page (it's got be at least 20yrs old)

The main.css file it imports dates itself to March 9 of 2005, and is housed in an "ancient history" section of the website that covers everything before October 26, 2010, so: "sometime between those two years" =P

Its first appearance on the WayBack Machine is October 13, 2009, which narrows the range somewhat.

Re: How big are factorials?

#15
post #11
post #6

A quick and dirty approximation of the number of digits in n! is n lg n, which approximates n! from above, via the inequality 1 * 2 * … * n ≤ n * … * n. (This approximation should be familiar to many from an algorithmics class.) For a tighter bound, use n lg n - n/2, or a better approximation of ln 10 in place of 1/2 if you wish. This comes from Stirling's approximation which notes that ln n! = n ln n - n + O(ln n).

> (This approximation should be familiar to many from an algorithmics class.) You need both sides though :) What makes it interesting for estimating algorithmic complexity is that \log{n!} \in \Theta(n \log n). One side is obvious as you note, the other less so, but there's a famous trick to do both at once: \log{n!} = \log{\prod_{h=0}^{n} h} = \sum_{h=0}^{n} \log{h} Therefore, \int_0^n \log{x} dx \le \log{n!} \le \i…

Sure, I could've said "upper bound" :P

Re: How big are factorials?

#16
post #13

lg(n!) grows roughly as (n lg n). Constants matter, of course, but to that's the rough estimate. As an aside, if you take numbers from 0 to (n-1) in an array, there are n! configurations, so representing each configuration or differentiating each configuration take n lg n bits. So, in some sense, taking a mapping that's able to differentiate the input state to map to the ordered state takes at least O(n lg n) time, t…

[deleted]

Re: How big are factorials?

#18
post #8
post #3

Reminds me of: Professor asked us to find the biggest factorial using C programming language. And then using LISP. You can imagine our surprise.

There is a algorithm call Prime Swing Factorial that can compute large factorials exactly in arbitrary precision math using prime factorization. Like 10000000! in under second depending of how optimized the math library it. Probably like 100x faster than the normal method.

With Lisp you can use iterative algos and get that under a second too. SBCL can be ridiculously fast; and if you optimize the compilation for integers... the speed gets really close to your solution.

Re: How big are factorials?

#19
This brings to mind the analysis in Bender & Orszag; they approach this through difference equations (a bit of a lost art in formal mathematics; very 19th-century feel) rather than integration.

Instead of introducing the gamma function, they instead start from the observation that log(F_n) - log(F_n-1) = log(n), so treating this difference as analogous to integration, it says that F_n ~= nlogn + n as the leading asymptotic behavior. This is clear just by substitution and algebra; no calculus necessary (though it helps to "know the answer beforehand").

From there you can treat the error term in this as F_n = n^n * e^n * E_n and plug that into the same relationship (F_n = n * F_n-1) to derive what that error term looks like asymptotically, and end up in the same place that the integration on the OP leads to.

Post reply on HN