Python - Using Recursion to find the sum of Max and Min in a nested list

Question

Here's everything I got so far... I can't figure what I have done wrong

First my helper function

def max_min(l):

    if isinstance (l[0], list):
        result = max_min(l[0])

    elif len(l) == 2:
        if l[0] < l[1]:
            result = l[0], l[1]
        else:
            result = l[1], l[0]

    else:
        Min, Max = max_min(l[1:])
        if l[0] <= Min:
            result = l[0], Max
        elif l[0] >= Max:
            result = Min, l[0]
        else:
            result = Min, Max

    return result

When tried to do this

l = [6, 3, 7, 5, 5, 2, [3, 2], 1]
print max_min(l)

It gives me (2, 7) which i expected to be (1, 7)

I'm out of ideas... anyone can point me out the directions?

is using recursion critical to the application? would be much simpler to convert it to a single list then sort it and take the first and last elements — Tom, Feb 24 '16 at 16:11
Run your code through a debugger and see where it doesn't behave like you expect. — Vincent Savard, Feb 24 '16 at 16:14
Is this homework? There's no reason to do this in real code. — Daenyth, Feb 24 '16 at 16:23
Yea this is homework... well exercise~ We are not allow to go through the list more than once — user984343, Feb 24 '16 at 16:40
@user984343. In that case, this is XY problem. There are much better options than recursion. However, points for trying and almost succeeding on your own. — Mad Physicist, Feb 24 '16 at 21:01

score 4 · Answer 1 · answered Feb 24 '16 at 16:18

The moment your program reaches a nested list, it stops evaluating the other elements. The block if isinstance (l[0], list) ensures that if there is a nested list, the remaining elements are not evaluated since Min, Max = max_min(l[1:]) is never called.

You can fix the if block with something like this:

if isinstance (l[0], list):
    Nested_Min, Nested_Max = max_min(l[0])
    Remainder_Min, Remainder_Max = max_min(l[1:])
    Min = Nested_Min if Nested_Min < Remainder_Min else Remainder_Min
    Max = Nested_Max if Nested_Max > Remainder_Max else Remainder_Max
    result = Min, Max

You should also replace the check for if len(l) == 2 with:

if len(l) == 1:
    result = l[0], l[0]

That way your function will not fail for single-element lists. Finally, add something like the following at the beginning:

if not l:
    return ()

@user984343. In that case, perhaps selecting this answer would be in order. — Mad Physicist, Feb 24 '16 at 17:01

Tom Karzes · Answer 2 · 2016-02-24T22:10:02.133

0

Try this instead:

def min_max(l):
    if isinstance(l, list):
        t = [min_max(v) for v in l]
        return min([m[0] for m in t]), max([m[1] for m in t])
    else:
        return l, l

Sample output:

>>> l = [6, 3, 7, 5, 5, 2, [3, 2], 1]
>>> min_max(l)
(1, 7)
>>>

Note that an empty list or sub-list will cause an error, so you might need to add a check for that if you care about it.

edited Feb 24 '16 at 22:10

answered Feb 24 '16 at 16:20

Tom Karzes

22,815
2
22
41

If the OP was going to use `min` or `max` he/she could just apply that to the original list – sedavidw Feb 24 '16 at 16:22
Neat solution. You may want to ask the OP if using `min` and `max` is allowed. Given the weird recursion constraints, I doubt it is. – Mad Physicist Feb 24 '16 at 16:22
1

@sedavidw. That is absolutely not true. Those functions would barf on a nested list. – Mad Physicist Feb 24 '16 at 16:22
@sedavidw No, because the list can contain nested lists. That's the whole point. Please read the post again. – Tom Karzes Feb 24 '16 at 16:23
You're not answering OP's question. – leongold Feb 24 '16 at 16:23
@sedavidw: `TypeError: unorderable types: list() < int()`. I am not sure what part of that "works just fine". – Mad Physicist Feb 24 '16 at 16:24
1

I retract my previous comments, they were in fact incorrect – sedavidw Feb 24 '16 at 16:24
1

@sedavidw You are wrong. Try this: `min([2, [1, 3]])`. That gives `2` rather than `1`. – Tom Karzes Feb 24 '16 at 16:24
1

OK. Works in Py2, but answer is not correct. Not even sure how it compares list to int. – Mad Physicist Feb 24 '16 at 16:26
@Mad Physicist All it's doing is comparing integers to lists, the same as the ordinary comparison operators do, which isn't the desired behavior. Python 2 doesn't give an error, but Python 3 does. – Tom Karzes Feb 24 '16 at 16:27
@TomKarzes. I realize it's comparing integers to lists, but how? – Mad Physicist Feb 24 '16 at 16:31
@Mad Physicist As far as I can tell, in Python 2 any integer compares as less than any list. – Tom Karzes Feb 24 '16 at 16:33
2

@TomKarzes. You are absolutely correct. And the reason is messed up. It's because lexicographically, 'int' < 'list'. Not kidding: http://stackoverflow.com/a/3270689/2988730 – Mad Physicist Feb 24 '16 at 16:37

score 0 · Answer 3 · answered Feb 24 '16 at 16:38

To expand on my comment you would still need to use recursion to flatten the list as you have a mix of integers and lists, the code would look as follows:

def flatten(l):
    tmp = []
    for i in l:
        if isinstance(i, int):
            tmp.append(i)
        elif isinstance(i, list):
            tmp += flatten(i)
        else:
            raise AttributeError("found unexpected type {t}".format(t=type(i)))
    return tmp

score 0 · Answer 4 · answered Feb 24 '16 at 17:10

Your recursive function can be simplified and improved at the same time. See the following for details:

#! /usr/bin/env python3


def main():
    array = [6, 3, 7, 5, 5, 2, [3, 2], 1]
    print(sum_min_max(array))


def sum_min_max(array):
    return (lambda a, b: a + b)(*get_min_max(array))


def get_min_max(array, minimum=+float('inf'), maximum=-float('inf')):
    if array:
        head, *tail = array
        if isinstance(head, (list, tuple)):
            minimum, maximum = get_min_max(head, minimum, maximum)
        else:
            if head < minimum:
                minimum = head
            if head > maximum:
                maximum = head
        minimum, maximum = get_min_max(tail, minimum, maximum)
    return minimum, maximum


if __name__ == '__main__':
    main()

Python - Using Recursion to find the sum of Max and Min in a nested list

4 Answers4