Python求和高阶函数

Question

I'm writing an iterative solution for summation, and it seems to give the correct answer. But I'm told by my tutor that it's giving the wrong result for non-commutative combine operations . I went to google but I'm still unsure what exactly it means...

Here is the recursive code I wrote:

def sum(term, a, next, b):
    # First recursive version
    if a > b:
        return 0
    else:
        return term(a) + sum(term, next(a), next, b)

def accumulate(combiner, base, term, a, next, b):
    # Improved version
    if a > b:
        return base
    else:
        return combiner(term(a), accumulate(combiner, base, term, next(a), next, b))

print(sum(lambda x: x, 1, lambda x: x, 5))
print(accumulate(lambda x,y: x+y, 0, lambda x: x, 1, lambda x: x, 5))
# Both solution equate to - 1 + 2 + 3 + 4 + 5 

This is the iterative version I wrote that gives the wrong results for non-commutative combine operations - Edit: accumulate_iter gives the wrong results when lambda x,y: x- y is used for combiner

def accumulate_iter(combiner, null_value, term, a, next, b):
    while a <= b:
        null_value = combiner(term(a), null_value)
        a = next(a)
    return null_value

Hoping if someone could provide a solution for this iterative version of accumulate

Answer 1

You accumulate_iter works fine when the combiner is commutative, but it gives different result when the combiner is non-commutative. That's because the recursive accumulate combine elements from the back to the front, but the iterative version combine them from the front to the back.

So what we need to do is to make accumulate_iter combine from behind, and following is a rewritten accumulate_iter :

def accumulate_iter(a, b, base, combiner, next, term):
    # we want to combine from behind, 
    # but it's hard to do that since we are iterate from ahead
    # here we first go through the process, 
    # and store the elements encounted into a list
    l = []
    while a <= b:
        l.append(term(a))
        a = next(a)
    l.append(base)
    print(l)

    # now we can combine from behind!
    while len(l)>1:
        l[-2] = combiner(l[-2], l[-1])
        l.pop()
    return l[0]