如何找到递归结果的总和

Question

First write a function called rec_dig_sum that takes in an integer and returns the recursive digit sum of that number.

Examples of recursive digit sums:

101 => 1+0+1 = 2
191 => 1+9+1 = 11 => 1+1 = 2
5697 => 5+6+9+7 = 27 => 2+7 = 9

Then use that function within another function called distr_of_rec_digit_sums , that returns a dictionary where the keys are recursive digit sums, and the values are the counts of those digit sums occurring between a low and high (inclusive) range of input numbers. Assume low and high are positive integers where high is greater than low, and neither low nor high are negative.

I have this as the first part:

def rec_dig_sum(n):
    total = 0
    for i in str(n):
      total += int(i)
    return total

Answer 1

It bothers me that the OP's recursive solution, and the other solutions presented here, have a for loop in the middle of them! Let's go fully (doubly) recursive on this problem! And since it's a number problem, let's also toss that str() function everyone else is using:

def rec_dig_sum(number):
    if number < 10:
        return number

    quotient, remainder = divmod(number, 10)

    return rec_dig_sum(rec_dig_sum(quotient) + remainder)

print(rec_dig_sum(101))
print(rec_dig_sum(191))
print(rec_dig_sum(5697))

OUTPUT

> python3 test.py
2
2
9
>

My example solution for the second function is conventional, but one of my few opportunites to use the dict.fromkeys() method:

def distr_of_rec_digit_sums(low=0, high=1500):
    histogram = dict.fromkeys(range(10), 0)

    for number in range(low, high + 1):  # a low and high (inclusive) range
        histogram[rec_dig_sum(number)] += 1

    return histogram

print(distr_of_rec_digit_sums(0, 1500))

OUTPUT

> python3 test.py
{0: 1, 1: 167, 2: 167, 3: 167, 4: 167, 5: 167, 6: 167, 7: 166, 8: 166, 9: 166}
> 

Answer 2

So for both parts of your question.

First, the recursive function:

def recursive_digits(n):
    total = sum([int(i) for i in str(n)])
    if total < 10:
        return total
    else:
        return recursive_digits(total)

Then you use it in the other function:

def distr_of_rec_digit_sums(low, high):
    
    digits = {item : 0 for item in range(10)}
    for i in range(low, high+1):
        digits[recursive_digits(i)] += 1
    return digits

And since the function name starts with 'distr', I guess, someone is interested in the distribution in digit sums. It is surprisingly (or unsurprisingly) uniform. This is for the range in your question (0 - 1500).

Answer 3

You are almost there

Without recursion it will be:

def rec_dig_sum(n):
  total = 0
  for i in str(n):
    total += int(i)
  return str(total)

t = "5697"
while len(t) != 1:
    t = rec_dig_sum(t)

print (t)

With recursion

We need a condition to break out of recursion, for this case we want to stop when the number of digits is 1 ie we will break if len(n) === 1 .

If not we calculate the current sum and and again start.

def rec_dig_sum(n):
  if len(n) == 1:
    return int(n)

  total = 0
  for i in str(n):
    total += int(i)
  
  return rec_dig_sum(str(total))

rec_dig_sum(str(5697))

If you are learning recursion and facing difficulty, start by writing the same using loops (non-recursive) and then try to make it recursive by targeting to remove the loop.

Answer 4

It looks like a recursive solution would fit better, such as:

def rec_dig_sum(n):
    if n < 0:
        raise Exception('the arg must be positive')

    # Stop condition: single number
    if n < 10:
        return n
    else:
        # Convert n into a str and each number back into int to be added
        total = sum(map(int, str(n)))
        return rec_dig_sum(total)