**π‘ Problem Formulation:** You have a collection of lists, and you need to extract only those lists whose maximum and minimum elements have a difference greater than a specified threshold, k. For example, given the list collection `[[1, 3, 5], [2, 4, 14], [0, 10, 20]]`

and a threshold `k = 10`

, the desired output is `[[2, 4, 14], [0, 10, 20]]`

because the differences between the extreme values in these lists are greater than 10.

## Method 1: Using List Comprehension and the `max()`

and `min()`

Functions

This method uses a list comprehension to iterate over each sublist and applies the `max()`

and `min()`

functions to find the maximum and minimum values. If the difference between these values is greater than the specified threshold, the sublist is included in the output list.

Here’s an example:

def extract_with_difference_gt_k(lst, k): return [sublist for sublist in lst if max(sublist) - min(sublist) > k] print(extract_with_difference_gt_k([[1, 3, 5], [2, 4, 14], [0, 10, 20]], 10))

Output:

[[2, 4, 14], [0, 10, 20]]

This snippet iterates through each sublist in the given list of lists. It calculates the maximum and minimum values of each sublist and includes the sublist in the result if the difference satisfies the condition. The result is printed out, showing the filtered sublists.

## Method 2: Using a Filter Function with a Lambda Expression

The filter function is combined with a lambda function to check the condition for each sublist. If the difference between the maximum and minimum values of a sublist is greater than `k`

, it is included in the result list.

Here’s an example:

def extract_with_difference_gt_k(lst, k): return list(filter(lambda sublist: max(sublist) - min(sublist) > k, lst)) print(extract_with_difference_gt_k([[1, 3, 5], [2, 4, 14], [0, 10, 20]], 10))

Output:

[[2, 4, 14], [0, 10, 20]]

This code uses the `filter()`

function to keep only those sublists where the difference between the largest and smallest numbers exceeds the threshold. The lambda function inside the `filter()`

function handles the comparison logic.

## Method 3: Using For Loops

An explicit for loop is used to iterate over each sublist, calculate the maximum and minimum values, and append the sublist to the result if the condition is met. This approach provides clarity and can be easier to understand for people who are not familiar with list comprehensions or lambda functions.

Here’s an example:

def extract_with_difference_gt_k(lst, k): result = [] for sublist in lst: if max(sublist) - min(sublist) > k: result.append(sublist) return result print(extract_with_difference_gt_k([[1, 3, 5], [2, 4, 14], [0, 10, 20]], 10))

Output:

[[2, 4, 14], [0, 10, 20]]

This snippet manually iterates through each sublist, similar to the first method, but uses a more traditional for loop construct. After the condition is checked, it appends passing sublists directly to the result list.

## Method 4: Using NumPy

If working with numeric data and performance is a concern, using NumPy can be more efficient. The method leverages NumPy array operation broadcasting to calculate the difference and apply the condition across the sublists. Note: NumPy needs to be installed for this method to work.

Here’s an example:

import numpy as np def extract_with_difference_gt_k(lst, k): arr = np.array(lst) return arr[np.ptp(arr, axis=1) > k].tolist() print(extract_with_difference_gt_k([[1, 3, 5], [2, 4, 14], [0, 10, 20]], 10))

Output:

[[2, 4, 14], [0, 10, 20]]

This code converts the list of lists into a NumPy array and uses the `np.ptp()`

function to compute the peak-to-peak (maximum-minimum) values along an axis. It then filters the array using a boolean mask and converts it back to a list.

## Bonus One-Liner Method 5: Using List Comprehension with Inline Max-Min Calculation

This one-liner approach uses list comprehension for brevity and combines the max-min calculation inline. It’s a condensed version of Method 1, useful for quick executions in scripts or oneliners.

Here’s an example:

print([sublist for sublist in [[1, 3, 5], [2, 4, 14], [0, 10, 20]] if max(sublist) - min(sublist) > 10])

Output:

[[2, 4, 14], [0, 10, 20]]

This is a shorthand, direct application of the logic without the need to define a function. It immediately prints the filtered sublists that meet the condition.

## Summary/Discussion

**Method 1: List Comprehension with Max and Min.**A concise and pythonic approach. The use of list comprehension could be less readable for those unfamiliar with the syntax.**Method 2: Filter with Lambda.**Functional and elegant, but the nesting of`max`

and`min`

functions inside a lambda might be confusing at first glance.**Method 3: Using For Loops.**Most straightforward approach, very readable but might be less efficient than list comprehension or NumPy.**Method 4: NumPy.**Very efficient for larger datasets, but introduces an external dependency which may not be ideal for all use cases.**Bonus Method 5: One-liner.**Great for quick tasks or scripting. It lacks reusability and could sacrifice readability for brevity.