Longest Consecutive Sequence

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        unordered_set<int> s(nums.begin(), nums.end());
        int best = 0;
        for (int v : s) {
            if (s.count(v - 1)) continue;       // not a start
            int cur = v, len = 1;
            while (s.count(cur + 1)) { ++cur; ++len; }
            best = max(best, len);
        }
        return best;
    }
};

func longestConsecutive(nums []int) int {
    s := map[int]bool{}
    for _, v := range nums {
        s[v] = true
    }
    best := 0
    for v := range s {
        if s[v-1] {
            continue
        }
        cur, length := v, 1
        for s[cur+1] {
            cur++
            length++
        }
        if length > best {
            best = length
        }
    }
    return best
}

from typing import List

class Solution:
    def longestConsecutive(self, nums: List[int]) -> int:
        s = set(nums)
        best = 0
        for v in s:
            if v - 1 in s:
                continue
            cur, length = v, 1
            while cur + 1 in s:
                cur += 1
                length += 1
            if length > best:
                best = length
        return best

function longestConsecutive(nums) {
    const s = new Set(nums);
    let best = 0;
    for (const v of s) {
        if (s.has(v - 1)) continue;
        let cur = v, len = 1;
        while (s.has(cur + 1)) {
            cur++;
            len++;
        }
        if (len > best) best = len;
    }
    return best;
}

class Solution {
    public int longestConsecutive(int[] nums) {
        Set<Integer> s = new HashSet<>();
        for (int v : nums) s.add(v);
        int best = 0;
        for (int v : s) {
            if (s.contains(v - 1)) continue;
            int cur = v, len = 1;
            while (s.contains(cur + 1)) {
                cur++;
                len++;
            }
            if (len > best) best = len;
        }
        return best;
    }
}

function longestConsecutive(nums: number[]): number {
    const s = new Set(nums);
    let best = 0;
    for (const v of s) {
        if (s.has(v - 1)) continue;
        let cur = v, len = 1;
        while (s.has(cur + 1)) {
            cur++;
            len++;
        }
        if (len > best) best = len;
    }
    return best;
}