Python: Finding the last index of min element?

问题:

For example [1,2,3,4,1,2]

has min element 1, but it occurs for the last time at index 4.

回答1:

a = [1,2,3,4,1,2]

a.reverse()
print len(a) - a.index(min(a)) - 1

Update after comment:

The side effect can be removed by reversing again (but of course that is quite inefficient).

a.reverse()

回答2:

>>> values = [1,2,3,4,1,2]
>>> -min((x, -i) for i, x in enumerate(values))[1]
4

No modification to the original list, works for arbitrary iterables, and only requires one pass.

This creates an iterable of tuples with the first value being the original element from the list, and the second element being the negated index. When finding the minimum in this iterable of tuples the values will be compared first and then the indices, so you will end up with a tuple of (min_value, lowest_negative_index). By taking the second element from this tuple and negating it again, you get the highest index of the minimum value.

Here is an alternative version that is very similar, but uses a key function for min():

>>> min(range(len(values)), key=lambda i: (values[i], -i))
4

Note that this version will only work for sequences (lists, tuples, strings etc.).

回答3:

len(list_) - list_[::-1].index(min(list_)) - 1

Get the length of the list, subtract from that the index of the min of the list in the reversed list, and then subtract 1.

回答4:

Not so efficient (I'm a beginner in Python), but works fine as well. The idx will just hold the last index of minimum element. I think that M.Keijzers method is the best.

array = [1,2,3,4,1,2]
min_val = min(array) 
for i in range(len(array)):
    if array[i] == min_val:
        idx = i

print idx

回答5:

len(myList)-1 - myList[::-1].index(min(list))

This uses the slice notation list[::-1] to return a shallow copy of a reversed list, so that it doesn't change your original list, then searches for the minimum value in that list

>>>myList = [1,2,3,4,1,2]
>>>len(myList)-1 - myList[::-1].index(min(list))
4

回答6:

>>> from operator import itemgetter
>>> from itertools import izip,count
>>> min(izip(count(len(L)-1,-1), reversed(L)), key=itemgetter(1))[0]
4

---

Explanation

reversed returns iterator which goes through original list without creating temporary list:

>>> reversed(L)
<listreverseiterator object at 0x00E823B0>

izip and count are lazy, and there seems to be no byte-code execution, so I expect this solution to be pretty fast, and one-liner at that.

---

Time comparisons

http://ideone.com/ZQuge3

Solutions using index turned out to be fastest despite they have to make 2 passes over list. Other solutions create auxiliary tuples inside generators on each iteration and I think it is the reason why these solutions are slower. Even akson128's solution which invokes byte-code execution is still faster (because it doesn't have to create tuples).