The right way to find the max value in a 2d list?

Question

I'm trying to find the right max value from below dp. as you can see, the max value is 3.

dp = [[0, 0, 0, 1], [1, 1, 0, 1], [1, 2, 1, 1], [0, 1, 2, 2], [0, 1, 2, 3]]

When using max(max(dp)), i got 2, which is wrong. But why?

max(dp) gives me [1,2,1,1]. If the max is taken along the y axis, shouldn't max(dp) return [1,2,2,3]?? when using max([max(x) for x in dp]), i got 3, which is correct

Answer 1

Classic python knows only one dimension, if you pass values to a comparative method, then it'll compare them, it won't go further

The right way is max((max(x) for x in dp)) as you said (just used a generator instead of a list inside)

Using numpy you can handle multiple dimensions

import numpy as np
x = [[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]
print(np.max(np.array(x)))  # 12

---

For max(dp) you look for the max of the following values, which will be computed by looking each element index by index, the maximum at index 0 is 1, but you have 2 possiblities, so you go one index further and the max of that second index is 2 and you have the winner

[0, 0, 0, 1], 
[1, 1, 0, 1], 
[1, 2, 1, 1],  <<<
[0, 1, 2, 2], 
[0, 1, 2, 3]

---

As max(dp) == [1, 2, 1, 1] then max(max(dp)) == max([1, 2, 1, 1]) which is 2

Answer 2

The problem is python has no notion of multi-dimensional arrays built in.

When you call max on a list of lists, you end up with a list that is highest in the lexicographic order, not the one containing the highest element.

x = [ [4,2,3], [3,10,0] ]
max(x) == [4,2,3] # does not contain 10
max(max(x)) == 4 

In other words max(max(x)) in python is not the highest value over two axes of x, but rather the maximal value in an entry of x, that is highest under the default ordering of the objects there (which for lists is lexicographic).

The easiest way is to use numpy, which has a proper way of interpreting k-dimensional arrays

import numpy as np
np.max(x) == 10 # as expected

Answer 3

def largestNumber(list):
    result = []
    for i in range(0, len(list)):
        largestNumber = list[i][0]
        for j in range(0, len(list[i])):
            if list[i][j] > largestNumber:
                largestNumber = list[i][j]
        result.append(largestNumber)
    return max(result)


print(largestNumber([[0, 0, 0, 1], [1, 1, 0, 1],
      [1, 2, 1, 1], [0, 1, 2, 2], [0, 1, 2, 3]]))

Code Explanation:

1. Create a variable to store the results as an array.

2. Create an outer loop to iterate through the outer array.

3. Create a second variable to hold the largest number and initialize it with the first number. This must be outside an inner loop, so it won’t be reassigned until we find a larger number.

4. Create said inner loop to work with the sub-arrays.

5. Check if the element of the sub-array is larger than the currently stored largest number. If so, then update the number in the variable.

6. After the inner loop, save the largest number in the corresponding position inside the results array.

7. And finally, return the said array.

Thanks to @juanpa.arrivillaga for helping me make my code more precise. Both code snippets have similar code explanation:

def largestNumber(list):
    result = []
    for item in list:
        largestNumber = item[0]
        for j in item:
            if j > largestNumber:
                largestNumber = j
        result.append(largestNumber)
    return max(result)


print(largestNumber([[0, 0, 0, 1], [1, 1, 0, 1],
      [1, 2, 1, 1], [0, 1, 2, 2], [0, 1, 2, 3]]))

The second method employs a different method of using a for loop, which is concise than the for loop that has range() in it. It gets the job done in a relatively more pythonic way.