Editing Decimal range decomposition

[[Decimal range decomposition]] is a standard technique used to simplify problems that involve the digits of ranges (''i.e'', intervals) of natural numbers.<ref>Although this technique is standard, it is unclear whether it has a common name. The name "decimal range decomposition" was coined by an author of this article.</ref>

==Informal idea==
Consider the following problem: given natural number <math>N</math>, how many of the natural numbers between 1 and <math>N</math>, inclusive, have a (non-strictly) descending sequence of digits? That is, each digit is less than or equal to the digit on its left, if any. For example, 100 and 321 qualify, but 101 and 123 do not. Assume that the [[naive algorithm]] is not efficient enough as <math>N</math> can have up to, say, 15 digits, so performing <math>N</math> loop iterations is out of the question.

It is hard to find an explicit formula for this quantity, but notice that there are some ranges of natural numbers for which we ''can'' write down a closed form. For example, if the range, instead of being from 1 to <math>N</math>, were to be from 35000 to 35999, we know at a glance that the answer is 0, since any number starting with the prefix "35" does not have a descending digit sequence. If instead the range were 53000 to 53999, the question becomes: in how many ways can we fill in the digits <math>xyz</math> so that <math>53xyz</math> has a descending digit sequence? Well, clearly, each of the digits <math>xyz</math> can only be 0, 1, 2, or 3. How many ways are there to fill in three slots, each with one of four possible digits, so that the resulting sequence is descending? This can easily be calculated as the binomial coefficient <math>\binom{3 + 4 - 1}{4 - 1} = 20</math>.

So it is easy to see that if we are given a range of the form <math>[p \times 10^n, (p+1) \times 10^n)</math> with <math>p</math> nonzero (which we'll call an '''elementary range'''), then the number of integers in this range with descending digits is either zero if the prefix <math>p</math> itself does not have descending digits, or else <math>\binom{n + p_0}{p_0}</math> where <math>p_0</math> is the last digit of the prefix <math>p</math>. For example, the range 53000 to 53999 (inclusive) is represented by <math>p = 53, n = 3</math>.

If the actual range given is from 1 to <math>N</math>, then we can try to '''decompose''' this range into elementary ranges, compute the number of integers with descending digits in ''each'' elementary range as a simple binomial coefficient, and then sum the counts obtained in order to get the final answer. For example, if <math>N = 165</math>, then we can decompose the range [1, 123] as the ''disjoint union'' of the following ranges: [1, 2), [2, 3), [3, 4), [4, 5), [5, 6), [6, 7), [7, 8), [8, 9), [9, 10), [10, 20), [20, 30), [30, 40), [40, 50), [50, 60), [60, 70), [70, 80), [80, 90), [90, 100), [100, 110), [110, 120), [120, 130), [130, 140), [140, 150), [150, 160), [160, 161), [161, 162), [162, 163), [163, 164), [164, 165), [165, 166). Note that each range is elementary: each range corresponds to the entire set of natural numbers corresponding to some fixed prefix with some fixed number of arbitrary digits following.

==Formal definition==
The decimal range decomposition of the interval of natural numbers <math>[1, N)</math> is the disjoint union
:<math>[1, N) = \bigsqcup_i E(p_i, n_i)</math>
where <math>E(p_i, n_i)</math> denotes an elementary interval, with <math>p_i</math> is a positive integer<ref>Zero is disallowed in order to ensure that all the numbers in each elementary range have the same number of digits, and no number is treated as having leading zeroes.</ref> and <math>n_i</math> a nonnegative integer:
:<math>E(p_i, n_i) = [p_i \times 10^{n_i}, (p_i+1) \times 10^{n_i})</math>
and the set of elementary intervals used is as small as possible.

==Algorithm==
To obtain the decimal range decomposition of <math>[1, N)</math>, there are two stages. In the first stage, we count all integers that have fewer digits than <math>N</math>. That is, we decompose the range <math>[1, 10^n)</math>, where <math>n</math> is the largest possible integer such that this range is contained within <math>[1, N)</math>. That is, <math>n = \lfloor \log_{10} N \rfloor</math>. In the second stage, we count up to <math>N</math> by advancing the leftmost digit, then the next-to-leftmost, and so on, "honing in" on the digit sequence of <math>N</math>.

===First stage===
Compute <math>n = \lfloor \log_{10} N \rfloor</math>. Then decompose the range <math>[1, 10^n)</math> as
:<math>[1, 10^n) = \bigsqcup_{i=0}^{n-1} \bigsqcup_{j=1}^9 E(j, i)</math>

===Second stage===
It remains to decompose the range <math>[10^n, N)</math>, where <math>N</math> has the same number of digits as <math>10^n</math>. Let the digit sequence of <math>N</math> be denoted <math>\langle d_n d_{n-1} \ldots d_1 d_0 \rangle</math>. Then
:<math>[10^n, N) = \bigsqcup_{i=0}^n \bigsqcup_{j=0}^{d_i-1} E(\langle d_n d_{n-1} \ldots d_{i+1} j\rangle, i)</math>

===Implementation (C++)===
<syntaxhighlight lang="cpp">
#include <vector>
#include <utility>
std::vector<std::pair<long long, int>> drd(long long N) {
    std::vector<std::pair<long long, int>> res;
    int exponent = 0;
    long long pwr = 1;
    // stage 1
    while (N/pwr >= 10ll) {
        for (int d = 1; d <= 9; d++) {
            res.push_back({d, exponent});
        }
        pwr *= 10; exponent++;
    }
    // stage 2
    long long l = pwr;
    long long p = 1;
    while (l < N) {
        if (l + pwr <= N) {
            res.push_back({p, exponent});
            l += pwr;
            p++;
        } else {
            pwr /= 10; --exponent;
            p *= 10;
        }
    }
    return res;
}
</syntaxhighlight>

==Arbitrary ranges==
Thus, if we know how to compute <math>\sum_{x \in I} f(x)</math> efficiently for any elementary interval <math>I</math>, we can compute <math>\sum_{x=1}^{N-1} f(x)</math> efficiently using the decimal range decomposition. If we are given an arbitrary interval <math>[A, B]</math> instead for <math>x</math> to range over, then we just use the fact that
:<math>\sum_{x=A}^B f(x) = \sum_{x=1}^{B} f(x) - \sum_{x=1}^{A-1} f(x)</math>
and use decimal range decomposition on <math>[1, B+1)</math> and <math>[1, A)</math> separately.

==External links==
* {{Problem|mmm14d|Kuuhaku Numbers}}
* {{SPOJ|KPSUM|The Sum @ SPOJ}}

==Notes==
<references/>