My favorite one is with the 52! seconds:

Start a timer that will count down the number of seconds from 52! to 0. Then walk around the Earth’s equator with one step every billion years. Then, after you make your way around the earth equator (by taking 1 step every billion of years), you take one drop of water out of the Pacific Ocean. Then, you repeat the process of walking around the equator, and everytime you walk around, you keep draining one singular drop of water. After the ocean is fully drained, you refill the ocean and put a piece of paper underneath you. Now, you once again repeat this process of walking, draining, and placing papers. After your stack of papers has reached the Sun, you repeat another 1000 times.

After all this, you have completed just about a third of the timer.

https://sites.imsa.edu/hadron/2025/02/26/how-big-is-52/

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)

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.

Stirling's approximation is also used a lot in statistical mechanics, because you often have to calculate logs of state space sizes, which means lots of combinatorics and thus lots of factorials. Plus it's continuous so you can do calculus.

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

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.

This reminded me of tetration and Knuth's up-arrow notation. It's basically repeated exponentiation.

Searching now, I just learned of tetrofactorial, which is a factorial using tetration operations. There's also pentation which is repeated tetration.

And there's a whole wiki for it here: googology.fandom.com

It's fun because the numbers are so big it's basically infinity but any of those numbers is still nothing compared to infinity.

I came across an interesting feature of factorials while making the puzzle books at https://www.kakurokokoro.com

The widest two rows are nine digits across, but while the first can be any of arrangements of the digits 1-9, the second cannot repeat any digits in the same columns, and so it limits allowable permutations to the number of derangements — which is close to 9!/e (where e is Euler’s Constant 2.718…)

No idea what this has to do with the relationship of i and pi.

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

60! is more than the number of atoms in the observable universe. This is why wedding seating plans are hard. ;0)

Factorial (n) for n > 24 is greater than 10^n.

What's surprising (to many) is that

n! < exp(n log n)

I did factorials even under KLISP 23 with cons cells as fake integers:

https://t3x.org/klisp/22/index.html

Dog slow but the old n270 netbook (32 bit) handles big factorials >20 fine, and OFC it's instant under Common Lisp (SBCL) and Scheme (both S9 and Chicken).

This is restating Stirling's approximation, which has been known for three centuries (1730, de Moivre 1721). https://en.wikipedia.org/wiki/Stirling%27s_approximation