查找整个序列的数字总和的有效方法

Question

In the following code snippet I am finding the sum of digits of all odd number between the interval [a,b]

def SumOfDigits(a, b):
    s = 0
    if a%2 == 0:
        a+=1
    if b%2 == 0:
        b-=1   
    for k in range(a,b+1,2):
        s+= sum(int(i) for i in list(str(k)))
    return s

Is there an efficient way to accomplish the same? Any patterns, which is leading to a clear cut formula.

I did search in https://oeis.org

Answer 1

Avoid all the overhead of conversion to and from strings and work directly with the numbers themselves:

def SumOfDigits(a, b):
    result = 0
    for i in range(a + (not a % 2), b + 1, 2):
        while i:
            result += i % 10
            i //= 10
    return result

Answer 2

Of course there is a pattern. Let's look at the problem of summing up the digitsums of all – odd and even – numbers between a and b inclusively.

For example: 17 to 33

17  18  19    20  21  22  23  24  25  26  27  28  29    30  31  32  33

The middle section gives you the sum of all digits from 0 to 9 (45) plus ten times 2. The left section is 7 + 8 + 9 plus three times 1 and the right the sum of 0 + 1 + 2 + 3 plus four times 3.

The middle section can comprise several blocks of ten, for example if you calculate the range between 17 and 63, you get 40 times 45 plus ten simes the the digitsums from 2 to 5.

This gives you a recursive algorithm:

def ssum(n):
    return n * (n + 1) // 2

def dsum(a, b):
    res = 0

    if a == b:
        while a:
            res += a % 10
            a //= 10

    elif a < b:
        aa = a // 10
        bb = b // 10

        ra = a % 10
        rb = b % 10

        if aa == bb:
            res += ssum(rb) - ssum(ra - 1)
            res += (rb - ra + 1) * dsum(aa, bb)

        else:
            if ra > 0:
                res += 45 - ssum(ra - 1)
                res += (10 - ra) * dsum(aa, aa)
                aa += 1

            if rb < 9:
                res += ssum(rb)
                res += (rb + 1) * dsum(bb, bb)
                bb -= 1

            if aa <= bb:
                res += 45 * (bb - aa + 1)
                res += 10 * dsum(aa, bb) 

    return res

Now let's extend this to include only odd numbers. Adkust a so that it is even and b so that it is odd. Your sum of digit sums now runs over pairs of even and odd numbers, where even + 1 == odd . That means that the digitsum of the odd number id one more than the even number, because all except the last digits are the same and the last odd digit is one more than the even digit.

Therefore:

dsum(a, b) == oddsum + evensum

and:

oddsum - evensum == (b - a + 1) // 2

The function to sum the digitsums of all odd numbers is then:

def oddsum(a, b):
    if a % 2: a -= 1
    if b % 2 == 0: b -= 1

    d = (b - a + 1) // 2

    return (dsum(a, b) + d) // 2

When I looked at your comment about OEIS, I've noticed that the algorithm can probably be simplified by writing a function to sum the digits from all numbers from zero to n and then calculate the difference dsum(b) - dsum(a) . There are probably more opportunities for optimisation.