# 5 Best Ways to Find Length of Longest Consecutive Sublist with Unique Elements in Python

Rate this post

π‘ Problem Formulation: The task at hand involves computing the length of the longest consecutive subsequence within a list, such that each element in the subsequence is unique. For example, given the input `[1, 2, 2, 3, 4, 1]`, the desired output would be `4`, corresponding to the unique subsequence `[2, 3, 4, 1]`.

## Method 1: Using a Sliding Window Technique

This approach makes use of a sliding window to keep track of the unique elements. It expands the window when new unique elements are found and shrinks it when a duplicate is encountered, ensuring all elements within the window are unique. It is an efficient and popular solution for problems dealing with subarrays or subsequences.

Here’s an example:

```def longest_unique_sublist(lst):
seen = set()
left = 0
max_length = 0
for right in range(len(lst)):
while lst[right] in seen:
seen.remove(lst[left])
left += 1
max_length = max(max_length, right - left + 1)
return max_length

print(longest_unique_sublist([1, 2, 2, 3, 4, 1]))```

The output of this code snippet is:

`4`

The function `longest_unique_sublist()` iterates through the input list using two pointers to create a sliding window. The set called ‘seen’ tracks the unique elements. If a repetition is encountered, the left pointer moves right, excluding the repeated element, thereby maintaining uniqueness. The maximum length of the window is tracked as the size of the longest unique consecutive sublist.

## Method 2: Brute Force

This straightforward method uses two nested loops to check each possible consecutive sublist and determine if all its elements are unique, updating the maximum length found. It is the most direct approach but also the least efficient, with a higher time complexity than other methods.

Here’s an example:

```def longest_unique_sublist_brute(lst):
max_length = 0
for i in range(len(lst)):
unique_elements = set()
for j in range(i, len(lst)):
if lst[j] in unique_elements:
break
max_length = max(max_length, j - i + 1)
return max_length

print(longest_unique_sublist_brute([1, 2, 2, 3, 4, 1]))```

The output of this code snippet is:

`4`

The `longest_unique_sublist_brute()` function implements a brute-force approach by checking all possible consecutive sublists starting from each index. The set ‘unique_elements’ is used to store the elements and check for uniqueness. Although this approach is easy to understand and implement, it is not optimal for large lists due to its O(n^2) time complexity.

## Method 3: Optimized Brute Force with Early Termination

Enhancing the brute force method, we can include an early termination condition. As soon as a duplicate element is found, the inner loop breaks, avoiding unnecessary iterations. It slightly improves efficiency but still remains less optimal than techniques such as the sliding window.

Here’s an example:

```def longest_unique_sublist_optimized_brute(lst):
max_length = 0
for i in range(len(lst)):
unique = set()
for j in range(i, len(lst)):
if lst[j] in unique:
break
max_length = max(max_length, len(unique))
return max_length

print(longest_unique_sublist_optimized_brute([1, 2, 2, 3, 4, 1]))```

The output of this code snippet is:

`4`

This function, `longest_unique_sublist_optimized_brute()`, is a refinement of the brute force method that uses sets for efficient lookups. By breaking out of the inner loop upon finding a duplicate, it ensures the early termination of the loop for sequences with duplicates, which can reduce the number of operations compared to the pure brute force method but does not change its time complexity class.

## Method 4: Using Dictionary to Track Elements’ Indices

In this method, a dictionary is utilized to track the last index at which each element was seen. We walk through the list while keeping the start index of a potential unique sublist and update it when a previously seen element is encountered again. This approach leverages the fast lookup capabilities of hash tables.

Here’s an example:

```def longest_unique_sublist_with_dict(lst):
last_seen = {}
start = 0
max_len = 0
for i, val in enumerate(lst):
if val in last_seen and last_seen[val] >= start:
start = last_seen[val] + 1
last_seen[val] = i
max_len = max(max_len, i - start + 1)
return max_len

print(longest_unique_sublist_with_dict([1, 2, 2, 3, 4, 1]))```

The output of this code snippet is:

`4`

The `longest_unique_sublist_with_dict()` function takes advantage of dictionary lookups to efficiently track the most recent index of each element. This enables quick updates to the start index of the unique sublist when duplicates are found. The technique provides a time complexity similar to the sliding window approach, but with potentially better practical performance due to lower overhead.

## Bonus One-Liner Method 5: Leveraging itertools and More_itertools

Python’s itertools library and the third-party more_itertools library offer a concise way to achieve our goal. Using the `unique_justseen` function from more_itertools, we can achieve a one-liner solution that is elegant and Pythonic, albeit less performant for large datasets.

Here’s an example:

```from more_itertools import unique_justseen

print(max(len(list(g)) for g in unique_justseen([1, 2, 2, 3, 4, 1])))```

The output of this code snippet is:

`4`

This one-liner utilizes a generator expression to find the length of groups created by the `unique_justseen()` function, which yields unique elements while ignoring subsequent duplicate values. It’s a compact solution but relies on third-party libraries and might not be the most efficient option for very large lists.

## Summary/Discussion

• Method 1: Sliding Window Technique. Efficient for all cases. Best preferred method for performance. O(n).
• Method 2: Brute Force. Simple to implement. Not efficient for large data as it has O(n^2) complexity.
• Method 3: Optimized Brute Force with Early Termination. Slight improvement over the brute force. Still O(n^2) complexity.
• Method 4: Using Dictionary to Track Elements’ Indices. Efficient. Can offer practical performance improvements. Complexity is O(n).
• Method 5: Leveraging itertools and More_itertools. Elegant and concise. Not as performant compared to other methods. Depends on external library.