如何计算 integer 中递归总和为给定数字的数字对

Question

Here's what I need to do:

Write 1 function that passes 1 parameter(the given number)

Use recursion only

return the number of pairs of digits that sum to 10

For example, if the parameter is 734655, then it should return 3 as 7+3, 4+6 and 5+5 are 3 pairs that sum to 10

What I have come out with is:

begin with the 1st digit, check the rest all digits, then goto 2nd digit, check 3rd....to the last digit. The base case is when the current_index reaches the last digit/

It would be so easy to solve with loops, whereas I am asked to use recursion, I'm really confused about what should I do in each call, or if there would be a recursion within another recursion...

Answer 1

One way to solve this recursively operates on the count of digits. For a digit x that's present (has positive count), check if there is also some y such that x + y equals the specified total (eg, 10 ). If y is present (has positive count), return 1 plus the recursively calculated number of pairs in the remaining digits without x and y . If not, return the recursively calculated number of pairs in the remaining digits without x . The base case returns 0 when there are no digits remaining.

Here's an example implementation in Python. pair_present is a boolean, but gets converted to an integer when used in a sum ( 1 for True , and 0 for False ). num_pairs was written as a pure function, such that its arguments are not destructively modified.

from collections import Counter

def num_pairs(digits, total=10):
    try:
        x = next(digits.elements())
    except StopIteration:
        # base case: no digits
        return 0
    digits = digits - Counter({x: 1})
    y = total - x
    pair_present = digits[y] > 0
    digits = digits - Counter({y: 1})
    return pair_present + num_pairs(digits, total=total)

number = 734655
digits = Counter(int(c) for c in str(number))
print(num_pairs(digits))  # 3

A similar approach could operate directly on the string representation of the number, instead of the count of digits. For the first digit x in the number, check if there is also some y such that x + y equals the specified total (eg, 10 ). If y is present, return 1 plus the recursively calculated number of pairs in the remaining string without x and y . If not, return the recursively calculated number of pairs in the remaining string without x . The base case returns 0 when there are no digits remaining.

Here's an example implementation in Python.

def num_pairs(string, total=10):
    if len(string) == 0:
        return 0
    x = int(string[0])
    string = string[1:]  # remove x from string
    y = total - x
    pair_present = str(y) in string
    if pair_present:
        string = string.replace(str(y), '')  # remove y from string
    return pair_present + num_pairs(string, total=total)

number = 734655
print(num_pairs(str(number)))  # 3

Compared to the approaches above, the following iterative approach has the benefits that 1) it takes the number itself as input, 2) avoids the object copying in the earlier solutions (used earlier to avoid destructive modification of the input), and 3) is seemingly a more straightforward way to solve the problem.

from collections import Counter

def num_pairs(number, total=10):
    digits = Counter(int(c) for c in str(number))
    output = 0
    while True:
        x = next(digits.elements(), None)
        if x is None:
            return output
        digits[x] -= 1
        y = total - x
        if digits[y] > 0:
            output += 1
            digits[y] -= 1

print(num_pairs(734655))  # 3

An alternative way to solve the problem recursively is to convert the preceding iterative implementation to one that uses recursion in place of the loop, as shown in the example Python implementation below. Some languages (eg, Scheme) would use tail call optimization here so that each recursive call would not use any additional stack space. This is not the case for Python.

from collections import Counter

def num_pairs(number, total=10, _state=None):
    if _state is None:
        _state = {
            'digits': Counter(int(c) for c in str(number)),
            'result': 0
        }
    digits = _state['digits']
    x = next(digits.elements(), None)
    if x is None:
        return _state['result']
    digits[x] -= 1
    y = total - x
    if digits[y] > 0:
        _state['result'] += 1
        digits[y] -= 1
    return num_pairs(number, total, _state)

print(num_pairs(734655))  # 3

Additionally, a recursive solution could utilize sorting and binary search. First, sort the digits. For the first digit x , use binary search on the other digits to see if there is a y such that x + y equals the specified total. If y is present, return 1 plus the recursively calculated number of pairs in the remaining sorted digits. If not, return the recursively calculated number of pairs in the remaining digits. The base case returns 0 when there are no digits remaining. Special-case handling is required for the case where x + y equals the specified total and x == y , to prevent over-counting. Here's an example implementation in Python.

from bisect import bisect_left

def num_pairs(digits, total=10, _sorted=False):
    if len(digits) == 1:
        return 0
    if not _sorted:
        digits = sorted(digits)
    x = digits[0]
    digits = digits[1:]
    y = total - x
    if x > y:
        return 0
    # Use binary search to check for y's location.
    idx = bisect_left(digits, y)
    pair_present = idx < len(digits) and digits[idx] == y
    # If x + y == total and x == y, pop y to prevent over-counting.
    if pair_present and x == y:
        digits = digits[1:]
    return pair_present + num_pairs(digits, total=total, _sorted=True)

number = 734655
print(num_pairs([int(c) for c in str(number)]))  # 3