# 5 Best Ways to Get Indices of a List After Deleting Elements in Ascending Order in Python

Rate this post

π‘ Problem Formulation: The task is to determine the indices of a list that would remain after sequentially deleting the smallest elements until the list is empty. For example, given the list `[3, 1, 2]`, the order of deletion would be elements at indices `[1, 2, 0]`, respectively. This article explores five methods to programmatically identify these indices in Python.

## Method 1: Using Sorted Index Pairs

This method involves creating a list of tuples, where each tuple contains an element and its original index. By sorting this list and mapping the second elements (the original indices) to a new list, we get the desired index order for the deletions.

Here’s an example:

```arr = [3, 1, 2]
sorted_index_pairs = sorted(enumerate(arr), key=lambda x: x[1])
indices = [index for index, value in sorted_index_pairs]
print(indices)```

Output:

`[1, 2, 0]`

This snippet first creates a list of tuples with `enumerate(arr)`, sorts them by the original list values, and then extracts the indices representing the order of ascending value deletion.

## Method 2: Using Argsort from NumPy

For those with NumPy installed, we can take advantage of the `argsort()` function which returns the indices that would sort the array. This method is efficient and compact, especially for large lists.

Here’s an example:

```import numpy as np

arr = [3, 1, 2]
indices = np.argsort(arr).tolist()
print(indices)```

Output:

`[1, 2, 0]`

This code uses NumPy’s `argsort()` functionality to return a sequence of indices that sort the array in ascending order, which is then converted to a list.

## Method 3: Using List Comprehension and Min Function

This method involves repeatedly finding the smallest element and its index, then ‘deleting’ it from the list and updating the remaining indices. It’s a brute-force approach that’s simple to understand.

Here’s an example:

```arr = [3, 1, 2]
indices = []
for i in range(len(arr)):
min_index = arr.index(min(arr))
indices.append(min_index)
arr[min_index] = float('inf')

print(indices)```

Output:

`[1, 2, 0]`

Here, the `min()` function finds the smallest element, and `index()` gets its position. We then simulate deletion by setting the element to infinity, thus excluding it from subsequent calls to `min()`.

## Method 4: Using HeapQueue Pop Operation

The `heapq` module in Python offers a way to efficiently manage a heap queue or priority queue. We can push all elements with their indices into a heap and then pop them out to get the indices in the desired order.

Here’s an example:

```import heapq

arr = [3, 1, 2]
heap = [(value, i) for i, value in enumerate(arr)]
heapq.heapify(heap)
indices = [heapq.heappop(heap)[1] for _ in range(len(arr))]

print(indices)```

Output:

`[1, 2, 0]`

The code above demonstrates creating a min-heap from the array elements and their indices and then popping elements from the heap to get their indices in ascending order.

## Bonus One-Liner Method 5: Using Sorted and Lambda Function

This method combines Python’s `sorted()` function with a lambda to provide a quick one-liner. It’s similar to Method 1 but more succinct, which Pythonistas may appreciate for its brevity.

Here’s an example:

```arr = [3, 1, 2]
indices = [i for _, i in sorted((val, idx) for idx, val in enumerate(arr))]
print(indices)```

Output:

`[1, 2, 0]`

The one-liner utilizes list comprehension, `sorted()`, and `enumerate()` to accomplish the same as Method 1 but with a more compact syntax.

## Summary/Discussion

• Method 1: Using Sorted Index Pairs. Straightforward and uses native Python. Not the most efficient for large data sets.
• Method 2: Using Argsort from NumPy. Very efficient, especially for large arrays, but requires NumPy, which is an external library.
• Method 3: Using List Comprehension and Min Function. Easy to understand but inefficient for large lists due to its O(n^2) complexity.
• Method 4: Using HeapQueue Pop Operation. Efficient and elegant, suitable for large data sets, but relies on understanding of heap data structures.
• Bonus Method 5: One-Liner Using Sorted and Lambda Function. Concise and pythonic, but one-liners may be less readable to those unfamiliar with lambda functions and comprehensions.