007. Longest Alternating-Parity Streak

Why this mechanism works

The condition belongs to an edge between neighboring values. When an edge fails, the current element remains a valid singleton even though it cannot extend the previous run. That is why a failed edge restarts the state at one rather than zero.

State and boundaries

current is the alternating suffix ending at the current index. best is the maximum suffix length seen.

Protocol

1. Handle the empty list.
2. Seed a singleton run.
3. Compare each value's parity with its predecessor.
4. Extend on different parity, otherwise restart at one.
5. Update the best length.

Visualization

values:  1  2  5  8 10
parity:  O  E  O  E  E
length:  1  2  3  4  1

Python implementation

def alternating_parity(nums):
    if not nums:
        return 0
    current = best = 1
    for i in range(1, len(nums)):
        if nums[i] % 2 != nums[i - 1] % 2:
            current += 1
        else:
            current = 1
        best = max(best, current)
    return best

Worked execution

Recorded state changes after statements; L numbers refer to the solution file. Long traces are explicitly condensed.

L2 alternating_parity: if not nums:
nums=[1, 2, 5, 8, 10]

L4 alternating_parity: current = best = 1
nums=[1, 2, 5, 8, 10]; current=1; best=1

L5 alternating_parity: for i in range(1, len(nums)):
nums=[1, 2, 5, 8, 10]; current=1; best=1; i=1

L7 alternating_parity: current += 1
nums=[1, 2, 5, 8, 10]; current=2; best=1; i=1

L10 alternating_parity: best = max(best, current)
nums=[1, 2, 5, 8, 10]; current=2; best=2; i=1

L5 alternating_parity: for i in range(1, len(nums)):
nums=[1, 2, 5, 8, 10]; current=2; best=2; i=2

L7 alternating_parity: current += 1
nums=[1, 2, 5, 8, 10]; current=3; best=2; i=2

L10 alternating_parity: best = max(best, current)
nums=[1, 2, 5, 8, 10]; current=3; best=3; i=2

... 1 intermediate state changes omitted ...

L7 alternating_parity: current += 1
nums=[1, 2, 5, 8, 10]; current=4; best=3; i=3

L10 alternating_parity: best = max(best, current)
nums=[1, 2, 5, 8, 10]; current=4; best=4; i=3

L5 alternating_parity: for i in range(1, len(nums)):
nums=[1, 2, 5, 8, 10]; current=4; best=4; i=4

L9 alternating_parity: current = 1
nums=[1, 2, 5, 8, 10]; current=1; best=4; i=4

L2 alternating_parity: if not nums:
nums=[]

Why the solution is correct

The first singleton satisfies the contract. A differing parity creates a valid extension of the longest alternating suffix; matching parity makes every longer suffix invalid while leaving the singleton valid. Every candidate run is considered at its endpoint.

Time and space

O(n) time and O(1) auxiliary space.

Common mistakes

Checking signs instead of parity changes the problem. A reset to zero undercounts a new run beginning at the failed edge's right endpoint.

Reasoning card

Transfer exercise

Replace alternating parity with a fixed adjacent difference. Which state and reset rule survive unchanged?