Longest Consecutive Sequence

Linear membership scans

Use the array itself for membership checks. Skip repeated starting values, and begin a walk only when value - 1 is absent; otherwise, you'd be measuring the middle of a run.

def longest_consecutive(nums: list[int]) -> int:
    best = 0
    for i, value in enumerate(nums):
        if nums.index(value) != i:
            continue
        if value - 1 in nums:
            continue
 
        length = 1
        while value + length in nums:
            length += 1
        best = max(best, length)
 
    return best

The starts split the distinct values into disjoint runs, so the walks make O(n) membership queries in total. Each in or index query scans up to n array positions.

Time O(n²) in the worst case. Space O(1) beyond a few counters.

Sequence starts + hash set

A hash set stores unique values and answers membership questions in O(1) expected time. That removes both problems at once: duplicates disappear, and looking for the next integer no longer scans the array.

def longest_consecutive(nums: list[int]) -> int:
    values = set(nums)
    best = 0
 
    for value in values:
        if value - 1 in values:
            continue
 
        length = 1
        while value + length in values:
            length += 1
        best = max(best, length)
 
    return best

The start test is the key. In a run from 20 through 50, only 20 expands; the other 30 values fail the predecessor test. Across all runs, every distinct value is visited by exactly one expansion.

Time O(n) expected for building and scanning the set. Space O(n) for its distinct values.