# 5 Best Ways to Find All Good Indices in a Given Array in Python

π‘ Problem Formulation: We want to identify “good” indices in an array. A “good” index is defined as an array element that meets a specified condition, such as being greater than its neighbors. Given an array, for instance, `[1, 3, 5, 4, 3, 2]`, our goal is to find indices of elements that are local maxima, i.e., `[2]`, since element `5` at index `2` is greater than both its neighbors.

## Method 1: Iterative Comparison

This technique involves iterating through each element of the array and comparing it with its neighboring elements to determine if it is a “good” index. The function `find_good_indices()` takes an array as an input and returns a list of indices where the elements satisfy the local maxima condition.

Here’s an example:

```def find_good_indices(arr):
return [i for i in range(1, len(arr)-1) if arr[i-1]  arr[i+1]]

# Example usage:
my_array = [1, 3, 5, 4, 3, 2]
print(find_good_indices(my_array))
```

Output:

`[2]`

This code snippet defines the function `find_good_indices()` that iterates through the array, starting from the second element and ending at the second last element. The list comprehension checks for each element if it’s greater than both its neighbors. The indices that fulfill this condition are returned as a list.

## Method 2: Using NumPy Library

For those working with numerical data in Python, the NumPy library provides efficient array operations. This method uses NumPy’s vectorized operations and the `argwhere()` function for detecting “good” indices without explicit loops, thus often more efficient for large arrays.

Here’s an example:

```import numpy as np

def find_good_indices_np(arr):
arr = np.array(arr)
return np.argwhere((arr[1:-1] > arr[:-2]) & (arr[1:-1] > arr[2:])).flatten()

# Example usage:
my_array = [1, 3, 5, 4, 3, 2]
print(find_good_indices_np(my_array))
```

Output:

`[2]`

In this code, the array is first converted to a NumPy array. Then, `argwhere()` is used to find indices of elements that are greater than their immediate neighbors by creating boolean arrays of comparisons, and logical AND operation to combine them. The result is a list of indices containing local maxima.

## Method 3: Using the Pandas Library

Pandas is another powerful data manipulation library in Python which can also be used to find good indices. This involves converting the array into a Pandas Series and using the `shift()` method to compare each element with its neighbors.

Here’s an example:

```import pandas as pd

def find_good_indices_pd(arr):
s = pd.Series(arr)
return s[(s > s.shift(1)) & (s > s.shift(-1))].index.tolist()

# Example usage:
my_array = [1, 3, 5, 4, 3, 2]
print(find_good_indices_pd(my_array))
```

Output:

`[2]`

The code snippet begins by converting the array into a Pandas Series. It then shifts the series both forwards and backwards using the `shift()` method to perform the comparison. The indices of elements that are local maxima are then retrieved and converted to a list.

## Method 4: Using List Comprehension with zip()

List comprehensions provide a concise way to create lists in Python. Combined with the `zip()` function, we can iterate through triplets of consecutive elements to find “good” indices.

Here’s an example:

```def find_good_indices_zip(arr):
return [i for i, (prev, curr, next) in enumerate(zip(arr, arr[1:], arr[2:])) if prev < curr > next]

# Example usage:
my_array = [1, 3, 5, 4, 3, 2]
print(find_good_indices_zip(my_array))
```

Output:

`[2]`

In this example, `zip()` is used to create an iterator of tuples representing consecutive triplets of elements. The list comprehension then checks if the middle element of each triplet (the current element) is greater than the previous and next elements, adding the index of such elements to the resulting list.

## Bonus One-Liner Method 5: Using itertools and zip

The `itertools` library can generate complex iterators. Using `islice()` from itertools in combination with `zip()` allows us to create a condensed one-liner that finds “good” indices.

Here’s an example:

```from itertools import islice

def find_good_indices_itertools(arr):
return [i for i, (prev, curr, next) in enumerate(zip(arr, islice(arr, 1, None), islice(arr, 2, None))) if prev < curr > next]

# Example usage:
my_array = [1, 3, 5, 4, 3, 2]
print(find_good_indices_itertools(my_array))
```

Output:

`[2]`

The code presents a more compact approach using `itertools.islice()` to create iterators that skip the first 1 and 2 elements, respectively. The enumeration with `zip()` then allows us to compare triplets and isolate indices of local maxima.

## Summary/Discussion

• Method 1: Iterative Comparison. This method is straightforward and does not require external libraries. It’s easy to understand for beginners. However, it can be slow for very large arrays due to the use of explicit for-loops.
• Method 2: Using NumPy Library. NumPy provides optimized operations for numerical computations, making this approach fast for large datasets. However, it requires the NumPy library, which might not be suitable for projects that seek to minimize dependencies.
• Method 3: Using the Pandas Library. Pandas is versatile for data manipulation and is particularly useful when dealing with structured datasets. This method might be slower compared to NumPy for simple array operations and brings an additional dependency with it.
• Method 4: Using List Comprehension with zip(). This is a clean and Pythonic solution that uses built-in functions. It’s more efficient than explicit for-loops but may become unreadable with complex conditions.
• Bonus One-Liner Method 5: Using itertools and zip. Offers a powerful one-liner solution for those comfortable with more advanced Python constructs. However, it might be less readable and more difficult for beginners to follow.