python中的递归函数但返回值很奇怪

Question

I am trying to solve a primary equation with several variables. For example:11x+7y+3z=20. non-negative integer result only.

I use code below in python 3.5.1, but the result contains something like [...]. I wonder what is it? The code I have is to test every variables from 0 to max [total value divided by corresponding variable]. Because the variables may be of a large number, I want to use recursion to solve it.

def equation (a,b,relist):
    global total
    if len(a)>1:
        for i in range(b//a[0]+1):
            corelist=relist.copy()
            corelist+=[i]
            testrest=equation(a[1:],b-a[0]*i,corelist)
            if testrest:
                total+=[testrest]

        return total
    else:

        if b%a[0]==0:
            relist+=[b//a[0]]            
            return relist
        else:
            return False


total=[]
re=equation([11,7,3],20,[])

print(re)

the result is

[[0, 2, 2], [...], [1, 0, 3], [...]]

change to a new one could get clean result, but I still need a global variable:

def equation (a,b,relist):
global total
if len(a)>1:
    for i in range(b//a[0]+1):
        corelist=relist.copy()
        corelist+=[i]
        equation(a[1:],b-a[0]*i,corelist)

    return total
else:

    if b%a[0]==0:
        relist+=[b//a[0]]
        total+=[relist]
        return 
    else:
        return

total=[]
print(equation([11,7,3],20,[]))

Answer 1

I see three layers of problems here.

1) There seems to be a misunderstanding about recursion.

2) There seems to be an underestimation of the complexity of the problem you are trying to solve (a modeling issue)

3) Your main question exposes some lacking skills in python itself.

I will address the questions in backward order given that your actual question is "the result contains something like [...]. I wonder what is it?"

" [] " in python designates a list.

For example:

var = [ 1, 2 ,3 ,4 ]

Creates a reference " var " to a list containing 4 integers of values 1, 2, 3 and 4 respectively.

var2 = [ "hello", ["foo", "bar"], "world" ]

var2 on the other hand is a reference to a composite list of 3 elements, a string, another list and a string. The 2nd element is a list of 2 strings.

So your results is a list of lists of integers (assuming the 2 lists with "..." are integers). If each sublists are of the same size, you could also think of it as a matrix. And the way the function is written, you could end up with a composite list of lists of integers, the value " False " (or the value " None " in the newest version)

Now to the modeling problem. The equation 11x + 7y + 3z = 20 is one equation with 3 unknowns. It is not clear at all to me what you want to acheive with this program, but unless you solve the equation by selecting 2 independent variables, you won't achieve much. It is not clear at all to me what is the relation between the program and the equation save for the list you provided as argument with the values 11, 7 and 3.

What I would do (assuming you are looking for triplets of values that solves the equation) is go for the equation: f(x,y) = (20/3) - (11/3)x - (7/3)y. Then the code I would rather write is:

def func_f(x, y):
    return 20.0/3.0 - (11.0/3.0) * x - (7.0/3.0) * y

list_of_list_of_triplets = []
for (x, y) in zip(range(100),range(100)):
    list_of_triplet = [x, y, func_f(x,y)]
    list_of_list_of_triplets += [list_of_triplet] # or .append(list_of_triplet)

Be mindful that the number of solutions to this equation is infinite. You could think of it as a straight line in a rectangular prism if you bound the variables. If you wanted to represent the same line in an abstract number of dimensions, you could rewrite the above as:

def func_multi_f(nthc, const, coeffs, vars):
    return const - sum([a*b/nth for a,b in zip(coeffs, vars)])

Where nthc is the coefficient of the Nth variable, const is an offset constant, coeffs is a list of coefficients and vars the values of the N-1 other variables. For example, we could re-write the func_f as:

def func_f(x,y):
    return func_multi_f(3.0, 20.0, [11.0, 7.0], [x,y])

Now about recursion. A recursion is a formulation of a reducible input that can be called repetivitely as to achieve a final result. In pseudo code a recursive algorithm can be formulated as:

input = a reduced value or input items
if input has reached final state: return final value
operation = perform something on input and reduce it, combine with return value of this algorithm with reduced input.

For example, the fibonacci suite:

def fibonacci(val):
    if val == 1:
       return 1
    return fibonacci(val - 1) + val

If you wanted to recusively add elements from a list:

def sum_recursive(list):
    if len(list) == 1:
       return list[0]
    return sum_recursive(list[:-1]) + list[-1]

Hope it helps.

UPDATE

From comments and original question edits, it appears that we are rather looking for INTEGER solutions to the equation. Of non-negative values. That is quite different.

1) Step one find bounds: use the equation ax + by + cz <= 20 with a,b,c > 0 and x,y,z >= 0

2) Step two, simply do [(x, y, z) for x, y, z in zip(bounds_x, bounds_y, bounds_z) if x*11 + y*7 + z*3 - 20 == 0] and you will have a list of valid triplets.

in code:

def bounds(coeff, const):
    return [val for val in range(const) if coeff * val <= const]

def combine_bounds(bounds_list):
    # here you have to write your recusive function to build
    # all possible combinations assuming N dimensions

def sols(coeffs, const):
    bounds_lists = [bounds(a, const) for a in coeffs]
    return [vals for vals in combine_bounds(bounds_lists) if sum([a*b for a,b in zip(coeff, vals)] - const == 0)

Answer 2

Here is a solution built from your second one, but without the global variable. Instead, each call passes back a list of solutions; the parent call appends each solution to the current element, making a new list to return.

def equation (a, b):
    result = []
    if len(a) > 1:
        # For each valid value of the current coefficient,
        #    recur on the remainder of the list.
        for i in range(b // a[0]+1):
            soln = equation(a[1:], b-a[0]*i)

            # prepend the current coefficient
            #   to each solution of the recursive call.
            for item in soln:
                result.append([i] + item)
    else:
        # Only one item left: is it a solution?
        if b%a[0] == 0:
            # Success: return a list of the one element
            result = [[b // a[0]]]
        else:
            # Failure: return empty list
            result = []

    return result

print(equation([11, 7, 3], 20, []))