Python: estoy tratando de encontrar la máxima diferencia entre dos elementos en una lista

Necesito encontrar la máxima diferencia en una lista entre dos elementos. En la lista [1,2,3,4,5] la diferencia máxima es 4 (entre los elementos 1 y 5) que se usa para los bucles.

Este progtwig debe generar la ubicación de estos dos elementos (0 y 4) y sus valores (1 y 5).

Solo puedo averiguar cómo encontrar la diferencia máxima entre valores consecutivos, pero esto crea un problema si el máximo comienza en otro lugar, por ejemplo, [4,1,6,3,10,8] donde la mayor diferencia es entre 1 y 10 ( posiciones 1 y 4). ¿Alguien me puede ayudar?

Puede usar las funciones integradas max y min para encontrar los valores máximo y mínimo respectivamente y luego usar el index método de lista para encontrar sus índices en la lista.

 numlist = [1, 2, 3, 4, 5] max_val = max(numlist) min_val = min(numlist) max_pos = numlist.index(max_val) min_pos = numlist.index(min_val) 

En el enfoque ingenuo, simplemente tiene dos bucles nesteds que se aseguran de que cada elemento visite cada otro elemento de la lista. Como solo necesita comprobar cada par una vez, basta con iniciar el ciclo interno en el siguiente índice cada vez:

 lst = [1, 2, 3, 4, 5] max_i, max_j = None, None # stores the indexes max_d = -1 # stores the maximum distance we have seen so far # iterate through all indexes of the list for i in range(len(lst)): # iterate through all indexes, but starting from the index `i+1` for j in range(i + 1, len(lst)): d = abs(lst[i] - lst[j]) if d > max_d: # memorize everything if the distance is larger than what we know max_i, max_j, max_d = i, j, abs(d) print(max_i, max_j, max_d) # 0 4 4 

Por supuesto, con dos bucles nesteds, esto no es realmente eficiente, pero es esencialmente la solución para cuando realmente necesitas comparar cada elemento de la lista entre sí. En su caso de encontrar la distancia máxima, como otros lo señalaron, solo necesita mirar el elemento de lista más grande y más pequeño, que puede determinarse en tiempo lineal.


Como dijo en un comentario anterior, parece que solo se le permite usar para bucles, por lo que todavía podemos hacerlo eficiente, haciendo el mínimo / máximo encontrándonos en el tiempo lineal, iterando solo una vez:

 # set the current maximum and minimum to the first index max_i, min_i = 0, 0 # iterate the list from the second index for i in range(1, len(lst)): # check if we're larger than the current maximum if lst[i] > lst[max_i]: max_i = i # check if we're smaller than the current minimum if lst[i] < lst[min_i]: min_i = i distance = lst[max_i] - lst[min_i] print(min_i, max_i, distance) # 0 0 4 

Esto esencialmente hace lo mismo que la respuesta de mgilson. Simplemente hacemos el trabajo de las funciones incorporadas max y min nosotros mismos y encontramos el mínimo y el máximo manualmente.

Puede ordenar la lista primero, luego obtener los valores mínimo y máximo. Además, usa index() para obtener la posición de un elemento:

 L = [1, 2, 3, 4, 5] temp = sorted(L) # sorted list min = temp[0] max = temp[-1] # index -1 will give the last element 

Prueba:

 print "min", min, L.index(min) print "max", max, L.index(max) print "difference", max - min 

Salida:

 min 1 0 max 5 4 difference 4 

Esto se puede lograr usando max y min + enumerate :

 biggest_idx, biggest_value = max(enumerate(lst), key=lambda x: x[1]) smallest_idx, smallest_value = min(enumerate(lst), key=lambda x: x[1]) 

p.ej:

 >>> lst = [1,2,3,4,5] >>> biggest_idx, biggest_value = max(enumerate(lst), key=lambda x: x[1]) >>> smallest_idx, smallest_value = min(enumerate(lst), key=lambda x: x[1]) >>> print biggest_idx, biggest_value 4 5 >>> print smallest_idx, smallest_value 0 1 

Solo reste el valor máximo del valor mínimo. Esto es trivial en Python. Una buena forma de hacerlo es con itemgetter . Puede encontrar el índice y el valor mínimo / máximo al mismo tiempo si enumera los elementos en la lista, pero realiza el mínimo / máximo en los valores originales de la lista. Al igual que:

 >>> import operator >>> values = [1, 2, 3, 4, 5] >>> >>> min_index, min_value = min(enumerate(values), key=operator.itemgetter(1)) >>> min_index, min_value 0, 1 >>> max_index, max_value = max(enumerate(values), key=operator.itemgetter(1)) 4, 5 >>> difference = max_value - min_value >>> difference 4 
 min_i = 0 max_i = 0 for i in xrange(len(alist)): if alist[i] < alist[min_i]: min_i = i if alist[i] > alist[max_i]: max_i = i print "min=%d, max=%d" % (alist[min_i], alist[max_i]) print "min index=%d, max index=%d", (min_i, max_i) print "difference=%d" % (alist[min_i] - alist[max_i]) 

Puede ser tan simple como …

 numlist=[4,1,6,3,10,8] print('min value index : ' , numlist.index(min(numlist))) print('max value index : ' , numlist.index(max(numlist))) print('Max Difference : ',max(numlist)-min(numlist))