e.g. # of digits in 8722⁸⁷²² is 34371. 8722*log₁₀(8722) is 34370.05…so we take the next higher integer: 34371 (since, as you say, there is no such thing as a partial digit!).

But powers of 10 have that pesky 1 at the start. For example, 10¹⁰ has 11 digits, not 10*log₁₀(10), which is precisely 10. So we really need to take that “next higher integer” thing quite literally (9.99… –> 10, but 10 –> 11). In programming terms, it’s not ceil(x), I guess it’s floor(x+1) (same as floor(x)+1). Knowing that, it becomes a very handy tool.

Let the nerdiness continue:

We can do this in other bases, too… For example, in hex, the biggest number of a single digit is 0xf, equivalent to 9 in our base-10 example.

0xff^0xff has 510 digits
0xfff^0xfff has 12285 digits
0xffff^0xffff has 262140 digits
Of course, we need to be looking at the number of digits, represented in hex: 0x1fe, 0x2ffd, 0x3fffc…cool, fits the same pattern as my repeated-nines examples in base-10!

So, generally…the number of digits in these cases is n*(baseⁿ-1)

222₃^222₃ has 78 digits (in base-3)… And 3 * (3³ – 1) == 78…yay, it seems to work!

…but…

1111_b^1111_b has 59 (binary) digits…let’s see: 4 * (2⁴-1) == 60…doh!…why why why? Even simpler example: 11_b^11_b (3³==27==11011_b) has 5 binary digits, not 2 * (2²-1) == 6. Sigh… And I so wanted that formula to work in all cases… At the very least we can still calculate it correctly using logs:

>>> int(log(0b11,0b10)*0b11)+1
5
>>> int(log(0b1111,0b10)*0b1111)+1
59

(Of course, we will run into precision problems using floating point when dealing with very large numbers, which is why I like the other, integer-only formula. If only it also worked for base-2. If you can tell me why it doesn’t, I’d be glad to hear it!)

But base-10 logs should help!

The number of digits in (9^9) is log_10(9^9), which simplifies to 9 x log_10(9).  This gives 8.58… digits, which rounds up to 9 digits, since there’s no such thing as a partial digit.

99 x log_10(99) = 197.57, rounding up to 198
999 x log_10(999) = 2996.56, rounding up to 1997
9999 x log_10(9999) = 39995.56, rounding up to 39996

Here’s the long-precision results at each step:

8.588182584953924
197.56788426515745
2996.565922737756018
39995.565727233539808
499994.565707689566534
5999993.565705735294699
69999992.56570554342945

The fractional part seems to be converging on 0.5657… So, it looks like the trend will continue indefinitely!

So, next I got to thinking about exactly *why* this pattern occurs.

So, let’s start with the general formula to figure out the number of digits at the nth step which (as seen above) is:

digits = ((10^n) – 1) * log((10^n) – 1)

The second term, log((10^n)-1), will always evaluate to slightly less than n; think of it as (n – epsilon).

So, we can restate the formula as:

digits = ((10^n) – 1) * (n-epsilon)

Distributing the second term across the first, this simplifies to:

digits = (n-epsilon) 10^n – (n-epsilon)

We can drop the eps; just remember that the result will be slightly less than we get without the eps.  So,

digits ~= n(10^n) – n

or

digits ~= n * (10^n – 1)

So, let’s check this to see if we get the correct result at each step:

1:  1*(10-1) = 9, so we get slightly less than 9 digits.  But this rounds up to 9 since there’s no such thing as a partial digit.
2:  2*(100-1) = 198
3: 3*(1000-1) = 2997
.
.
.

So n * ((10^n) -1) indeed gives the number of digits at step n.

And we don’t need a calculator to compute this, since that formula will always give n-1 as the first digit(s), then n-1 nines, then 9-(n-1) as the last digits – exactly the pattern you’re seeing.

Why is that?  Because (10^n) – 1 will give us n nines.  Multiplying any series of nines by a digit x will always give (x-1) as the first digit; then lots of nines, and finally 9-(x-1) as the last digit.  Or to look at it another way, it’s like computing n*1000…00-n.  For example: 

99999 * 5 = 100000 * 5 – 5 =  50000 – 5 = 49995

So, that gives exactly the pattern you’re seeing.

I know that’s not quite a proof, especially since I’m fudging with an epsilon value and rounding, but it’s enough to convince me that this will work!

I’m sure there’s a much simpler way of looking at this, but (as you can see) I’ve already spent too much time thinking about this problem.

I think we may be nerds.  Or geeks.  Or whatever it is the kids these days  are calling people who get overly excited about obscure mathematical patterns.  :-)