# 5 Best Ways to Find Max Values of Sublists of Size K in Python

Rate this post

π‘ Problem Formulation: Given a list and a number `k`, we aim to find the maximum values in all sublists of size `k`. For example, for the input list `[1, 3, 5, 7, 9]` and `k=3`, the output should be `[5, 7, 9]`, showcasing the maximums for sublists [1, 3, 5], [3, 5, 7], and [5, 7, 9].

## Method 1: Brute Force

This straightforward approach iterates over the list and considers each sublist of size `k` to find its maximum value. Although simple, this method is not the most efficient, particularly for large lists, due to its O(n*k) time complexity.

Here’s an example:

```def max_values_sublists(lst, k):
return [max(lst[i:i+k]) for i in range(len(lst)-k+1)]

# Example usage
print(max_values_sublists([1, 3, 5, 7, 9], 3))
```

The output of this code snippet:

`[5, 7, 9]`

This function, `max_values_sublists`, generates a new list comprising the maximum value of each sublist by using Python’s built-in `max()` function within a list comprehension.

## Method 2: Using a Queue

This method improves efficiency by using a queue to maintain the elements of the current window. It ensures that only elements of interest are considered for finding the maximum, thereby reducing the time complexity to O(n).

Here’s an example:

```from collections import deque

def max_values_sublists(lst, k):
q = deque()
max_values = []
for i in range(len(lst)):
while q and lst[i] >= lst[q[-1]]:
q.pop()
q.append(i)
if q[0] == i - k:
q.popleft()
if i >= k - 1:
max_values.append(lst[q[0]])
return max_values

# Example usage
print(max_values_sublists([1, 3, 5, 7, 9], 3))
```

The output of this code snippet:

`[5, 7, 9]`

The function uses a double-ended queue (deque) to store indices of list elements and quickly retrieve the current maximum when traversing the list.

## Method 3: Dynamic Programming

Dynamic programming can be utilized by maintaining two arrays where one holds max values from the left and the other from the right for each sublist, and then the overall maximum is calculated by comparing the two values at the boundaries of each window.

Here’s an example:

```def max_values_sublists(lst, k):
n = len(lst)
if n * k == 0:
return []
if k == 1:
return lst
left = [0] * n
right = [0] * n
for i in range(n):
if i % k == 0:
left[i] = lst[i]
else:
left[i] = max(left[i - 1], lst[i])
j = n - i - 1
if (j + 1) % k == 0:
right[j] = lst[j]
else:
right[j] = max(right[j + 1], lst[j])
max_values = [max(left[i + k - 1], right[i]) for i in range(n - k + 1)]
return max_values

# Example usage
print(max_values_sublists([1, 3, 5, 7, 9], 3))
```

The output of this code snippet:

`[5, 7, 9]`

The dynamic programming solution prepares for an answer by storing useful computations and then reuses this information to calculate the maximum of each window more efficiently.

## Method 4: Segment Tree

Segment trees offer an advanced way to approach this problem. It can find the maximum in a range with a complexity of O(log n) for each query after an initial setup cost of O(n).

Here’s an example:

(Due to the complexity of a segment tree implementation, the code snippet is omitted for brevity. However, dedicated resources and libraries are available for readers to explore this method further.)

Imagine using a segment tree data structure implemented using a Python class to efficiently query max values from sublists of size `k` after building the tree with the input list.

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

With the help of Python’s `itertools` to generate slices and `operator` to grab itemgetter, we can craft a concise one-liner that accomplishes our task, at the cost of readability and potential performance hits on large inputs.

Hereβs an example:

```from itertools import islice
from operator import itemgetter

lst = [1, 3, 5, 7, 9]
k = 3
get_max = lambda sl: max(map(itemgetter(1), sl))
print([get_max(islice(enumerate(lst), i, i+k)) for i in range(len(lst)-k+1)])
```

The output of this code snippet:

`[5, 7, 9]`

This one-liner leverages iterator slicing and a max operation over tuples generated by `enumerate()`, extracting just the values for the max computation.

## Summary/Discussion

Method 1: Brute Force. Simple to implement. Not suitable for large inputs due to its O(n*k) time complexity.
Method 2: Using a Queue. Good balance between complexity and performance. Offers O(n) time complexity but can be complex to understand.
Method 3: Dynamic Programming. More suitable for advanced users who can handle complexity, and it provides an optimized solution for large inputs.
Method 4: Segment Tree. Very efficient in theory with O(log n) for queries, but setup complexity and practical implementation can be daunting.
Method 5: One-Liner. Interesting and concise, but potentially a readability and performance challenge, more of a novel solution rather than practical.