需要帮助理解python的递归

Question

I am new to recursion and want to know what is the logic to the following code.

The question is the powerSums question on hackerrank: https://www.hackerrank.com/challenges/the-power-sum/problem?isFullScreen=true

def powerSum(X, N, current = 1):
    pw = pow(current, N)
    if pw > X:
        return 0
    elif pw == X:
        return 1
    else:
        return powerSum(X, N, current+1) + powerSum(X-pw, N, current+1)

Also, I had been trying to convert the answer to a nested list or tuple of the set of values, but cannot seem to figure it out. How can this be done?

Eg, for a case where X=5 and N=2, the solution I want to yield is: [(10), (6,8), (1,3,4,5,7)] instead of 3, which the above code is yielding.

Answer 1

Your current code is returning the number of solutions. There are two recursive calls, following the two base cases. In the first recursive call, we're checking how many solutions exist for X without including current**N . The second recursive check tests how many solutions exist if we do include current**N .

If you want to return the actual solutions themselves (as a list of tuples), you'd need to change the code a bit.

Start with the base cases. If pw > X , there's no solution with current this large, so we should return an empty list. If pw == X , then we've found a solution, and should return a one-element list, containing the one element tuple (current,) (note the trailing comma, which is necessary to make the parentheses form a tuple, rather than just being for order of operations).

The recursive cases need to get a little more complicated too. Both calls will return lists, which we want to combine. For the first recursion, we can just use the returned list as is. For the second one, we'll need to add our current value to the start of each tuple. I suggest using a generator expression (though a list comprehension could also work if you wanted to concatenate the lists with + instead of using list.extend ).

def powerSum(X, N, current = 1):
    pw = pow(current, N)
    if pw > X:
        return []
    elif pw == X:
        return [(current,)]
    else:
        result = powerSum(X, N, current+1)
        result.extend((current,) + tup for tup in powerSum(X-pw, N, current+1))
        return result