One of my favourite integer sequences is what I call the digit-line. You create it by taking this very familiar integer sequence:

• 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20…

And turning it into this one:

• 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 0, 1, 1, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 1, 7, 1, 8, 1, 9, 2, 0… (A033307 in the Online Encyclopedia of Integer Sequences)

You simply chop all numbers into single digits. What could be simpler? Well, creating the digit-line couldn’t be simpler, but it is in fact a very complex object. There are hidden depths in its patterns, as even a brief look will uncover. For example, you can try counting the digits as they appear one-by-one in the line and seeing whether the digit-counts compare. Do the 1s of the digit-line always outnumber the 0s, as you might expect? Yes, they do (unless you start the digit-line 0, 1, 2, 3…). But do the 2s always outnumber the 0s? No: at position 2, there’s a 2, and at position 11 there’s a 0. So that’s one 2 and one 0. Does it happen again? Yes, it happens again at the 222nd digit of the digit-line, as below:

1, 2_count=1, 3, 4, 5, 6, 7, 8, 9, 1, 0_count=1, 1, 1, 1, 2₂, 1, 3, 1, 4, 1, 5, 1, 6, 1, 7, 1, 8, 1, 9, 2₃, 0₂, 2₄, 1, 2₅, 2₆, 2₇, 3, 2₈, 4, 2₉, 5, 2₁₀, 6, 2₁₁, 7, 2₁₂, 8, 2₁₃, 9, 3, 0₃, 3, 1, 3, 2₁₄, 3, 3, 3, 4, 3, 5, 3, 6, 3, 7, 3, 8, 3, 9, 4, 0₄, 4, 1, 4, 2₁₅, 4, 3, 4, 4, 4, 5, 4, 6, 4, 7, 4, 8, 4, 9, 5, 0₅, 5, 1, 5, 2₁₆, 5, 3, 5,4, 5, 5, 5, 6, 5, 7, 5, 8, 5, 9, 6, 0₆, 6, 1, 6, 2₁₇, 6, 3, 6, 4, 6, 5, 6, 6, 6, 7, 6, 8, 6, 9, 7, 0₇, 7, 1, 7, 2₁₈, 7, 3, 7, 4, 7, 5, 7, 6, 7, 7, 7, 8, 7, 9, 8, 0₈, 8, 1, 8, 2₁₉, 8, 3, 8, 4, 8, 5, 8, 6, 8, 7, 8, 8, 8, 9, 9, 0₉, 9, 1, 9, 2₂₀, 9, 3, 9, 4, 9, 5, 9, 6, 9, 7, 9, 8, 9, 9, 1, 0₁₀, 0₁₁, 1, 0₁₂, 1, 1, 0₁₃, 2₂₁, 1, 0₁₄, 3, 1, 0₁₅, 4, 1, 0₁₆, 5, 1, 0₁₇, 6, 1, 0₁₈, 7, 1, 0₁₉, 8, 1, 0₂₀, 9, 1, 1, 0₂₁…

So count(2) = count(0) = 1 at digit 11 of the digit-line in the 0 of what was originally 10. And count(2) = count(0) = 21 @ digit 222 in the 0 of what was originally 110. Is a pattern starting to emerge? Yes, it is. Here are the first few points at which the count(2) = count(0) in the digit-line of base 10:

1 @ 11 in 10
21 @ 222 in 110
321 @ 3333 in 1110
4321 @ 44444 in 11110
54321 @ 555555 in 111110
654321 @ 6666666 in 1111110
7654321 @ 77777777 in 11111110
87654321 @ 888888888 in 111111110
987654321 @ 9999999999 in 1111111110
10987654321 @ 111111111110 in 11111111110
120987654321 @ 1222222222221 in 111111111110
[...]

The count(2) = count(0) = 321 at position 3333 in the digit-line, and 4321 at position 44444, and 54321 at position 555555, and so on. I don’t understand why these patterns occur, but you can predict the count-and-position of 2s and 0s easily until position 9999999999, after which things become more complicated. Related patterns for 2 and 0 occur in all other bases except binary (which doesn’t have a 2 digit). Here’s base 6:

1 @ 11 in 10 (1 @ 7 in 6)
21 @ 222 in 110 (13 @ 86 in 42)
321 @ 3333 in 1110 (121 @ 777 in 258)
4321 @ 44444 in 11110 (985 @ 6220 in 1554)
54321 @ 555555 in 111110 (7465 @ 46655 in 9330)
1054321 @ 11111110 in 1111110 (54121 @ 335922 in 55986)
12054321 @ 122222221 in 11111110 (380713 @ 2351461 in 335922)
132054321 @ 1333333332 in 111111110 (2620201 @ 16124312 in 2015538)
1432054321 @ 14444444443 in 1111111110 (17736745 @ 108839115 in 12093234)
15432054321 @ 155555555554 in 11111111110 (118513705 @ 725594110 in 72559410)
205432054321 @ 2111111111105 in 111111111110 (783641641 @ 4788921137 in 435356466)
2205432054321 @ 22222222222220 in 1111111111110 (5137206313 @ 31345665636 in 2612138802)

And what about comparing other pairs of digits? In fact, the count of all digits except 0 matches infinitely often. To write the numbers 1..9 takes one of each digit (except 0). To write the numbers 1 to 99 takes twenty of each digit (except 0). Here’s the proof:

1₁, 2₁, 3₁, 4₁, 5₁, 6₁, 7₁, 8₁, 9₁, 1₂, 0₁, 1₃, 1₄, 1₅, 2₂, 1₆, 3₂, 1₇, 4₂, 1₈, 5₂, 1₉, 6₂, 1₁₀, 7₂, 1₁₁, 8₂, 1₁₂, 9₂, 2₃, 0₂, 2₄, 1₁₃, 2₅, 2₆, 2₇, 3₃, 2₈, 4₃, 2₉, 5₃, 2₁₀, 6₃, 2₁₁, 7₃, 2₁₂, 8₃, 2₁₃, 9₃, 3₄, 0₃, 3₅, 1₁₄, 3₆, 2₁₄, 3₇, 3₈, 3₉, 4₄, 3₁₀, 5₄, 3₁₁, 6₄, 3₁₂, 7₄, 3₁₃, 8₄, 3₁₄, 9₄, 4₅, 0₄, 4₆, 1₁₅, 4₇, 2₁₅, 4₈, 3₁₅, 4₉, 4₁₀, 4₁₁, 5₅, 4₁₂, 6₅, 4₁₃, 7₅, 4₁₄, 8₅, 4₁₅, 9₅, 5₆, 0₅, 5₇, 1₁₆, 5₈, 2₁₆, 5₉, 3₁₆, 5₁₀, 4₁₆, 5₁₁, 5₁₂, 5₁₃, 6₆, 5₁₄, 7₆, 5₁₅, 8₆, 5₁₆, 9₆, 6₇, 0₆, 6₈, 1₁₇, 6₉, 2₁₇, 6₁₀, 3₁₇, 6
₁₁, 4₁₇, 6₁₂, 5₁₇, 6₁₃, 6₁₄, 6₁₅, 7₇, 6₁₆, 8₇, 6₁₇, 9₇, 7₈, 0₇, 7₉, 1₁₈, 7₁₀, 2₁₈, 7₁₁, 3₁₈, 7₁₂, 4₁₈, 7₁₃, 5₁₈, 7₁₄, 6₁₈, 7₁₅, 7₁₆, 7₁₇, 8₈, 7₁₈, 9₈, 8₉, 0₈, 8₁₀, 1₁₉, 8₁₁, 2₁₉, 8₁₂, 3₁₉, 8₁₃, 4₁₉, 8₁₄, 5₁₉, 8₁₅, 6₁₉, 8₁₆, 7₁₉, 8₁₇, 8₁₈, 8₁₉, 9₉, 9₁₀, 0₉, 9₁₁, 1₂₀, 9₁₂, 2₂₀, 9₁₃, 3₂₀, 9₁₄, 4₂₀, 9₁₅, 5₂₀, 9₁₆, 6₂₀, 9₁₇, 7₂₀, 9₁₈, 8₂₀, 9₁₉, 9₂₀…

And what about writing 1..999, 1..9999, and so on? If you think about it, for every pair of non-zero digits, d1 and d2, all numbers containing one digit can be matched with a number containing the other. 100 → 200, 111 → 222, 314 → 324, 561189571 → 562289572, and so on. So in counting 1..999, 1..9999, 1..99999, you use the same number of non-zero digits. And once again a pattern emerges:

count(0) = 0; count(1) = 1; count(2) = 1; count(3) = 1; count(4) = 1; count(5) = 1; count(6) = 1; count(7) = 1; count(8) = 1; count(9) = 1 (writing 1..9)
count(0) = 9; count(1) = 20; count(2) = 20; count(3) = 20; count(4) = 20; count(5) = 20; count(6) = 20; count(7) = 20; count(8) = 20; count(9) = 20 (writing 1..99)
0: 189; 1: 300; 2: 300; 3: 300; 4: 300; 5: 300; 6: 300; 7: 300; 8: 300; 9: 300 (writing 1..999)
0: 2889; 1: 4000; 2: 4000; 3: 4000; 4: 4000; 5: 4000; 6: 4000; 7: 4000; 8: 4000; 9: 4000 (writing 1..9999)
0: 38889; 1: 50000; 2: 50000; 3: 50000; 4: 50000; 5: 50000; 6: 50000; 7: 50000; 8: 50000; 9: 50000 (writing 1..99999)
0: 488889; 1: 600000; 2: 600000; 3: 600000; 4: 600000; 5: 600000; 6: 600000; 7: 600000; 8: 600000; 9: 600000 (writing 1..999999)
0: 5888889; 1: 7000000; 2: 7000000; 3: 7000000; 4: 7000000; 5: 7000000; 6: 7000000; 7: 7000000; 8: 7000000; 9: 7000000 (writing 1..9999999)
[...]

And here’s base 6 again:

0: 0; 1: 1; 2: 1; 3: 1; 4: 1; 5: 1 (writing 1..5)
0: 5; 1: 20; 2: 20; 3: 20; 4: 20; 5: 20 (writing 1..55 in base 6)
0: 145; 1: 300; 2: 300; 3: 300; 4: 300; 5: 300 (writing 1..555)
0: 2445; 1: 4000; 2: 4000; 3: 4000; 4: 4000; 5: 4000 (writing 1..5555)
0: 34445; 1: 50000; 2: 50000; 3: 50000; 4: 50000; 5: 50000 (writing 1..55555)
0: 444445; 1: 1000000; 2: 1000000; 3: 1000000; 4: 1000000; 5: 1000000 (writing 1..555555)
0: 5444445; 1: 11000000; 2: 11000000; 3: 11000000; 4: 11000000; 5: 11000000 (writing 1..5555555)
0: 104444445; 1: 120000000; 2: 120000000; 3: 120000000; 4: 120000000; 5: 120000000 (writing 1..55555555)
0: 1144444445; 1: 1300000000; 2: 1300000000; 3: 1300000000; 4: 1300000000; 5: 1300000000 (writing 1..555555555)