128. Longest consecutive sequence

#include <stdlib.h>

static int cmp(const void *a, const void *b) {
    return *(const int *)a - *(const int *)b;
}

int longestConsecutive(int *nums, int numsSize) {
    if (numsSize == 0) {
        return 0;
    }

    qsort(nums, numsSize, sizeof(int), cmp);

    int longest = 1;
    int count = 1;

    for (int i = 1; i < numsSize; i++) {
        if (nums[i] == nums[i - 1]) {
            continue;
        }

        if (nums[i] == nums[i - 1] + 1) {
            count++;
        } else {
            count = 1;
        }

        if (count > longest) {
            longest = count;
        }
    }

    return longest;
}

#include <unordered_set>
#include <vector>
using namespace std;

class Solution {
public:
  int longestConsecutive(vector<int> &nums) {
    int count = 0;
    int max = 0;
    unordered_set<int> set(nums.begin(), nums.end());

    for (int n : set) {
      if (!set.contains(n - 1)) {
        count = 1;

        while (set.contains(n + count))
          count++;

        if (count > max)
          max = count;
      }
    }

    return max;
  }
};

package main

func longestConsecutive(nums []int) int {
    set := make(map[int]bool, len(nums))
    for _, n := range nums {
        set[n] = true
    }

    longest := 0

    for n := range set {
        if !set[n-1] {
            count := 1

            for set[n+count] {
                count++
            }

            if count > longest {
                longest = count
            }
        }
    }

    return longest
}

import java.util.HashSet;
import java.util.Set;

class Solution {
    public int longestConsecutive(int[] nums) {
        Set<Integer> set = new HashSet<>();
        for (int n : nums) {
            set.add(n);
        }

        int longest = 0;

        for (int n : set) {
            if (!set.contains(n - 1)) {
                int count = 1;

                while (set.contains(n + count)) {
                    count++;
                }

                longest = Math.max(longest, count);
            }
        }

        return longest;
    }
}

class Solution {
  longestConsecutive(nums) {
    const set = new Set(nums);
    let longest = 0;

    for (const n of set) {
      if (!set.has(n - 1)) {
        let count = 1;

        while (set.has(n + count)) {
          count++;
        }

        longest = Math.max(longest, count);
      }
    }

    return longest;
  }
}

class Solution:
    def longestConsecutive(self, nums: list[int]) -> int:
        num_set = set(nums)
        longest = 0

        for n in num_set:
            if n - 1 not in num_set:
                count = 1

                while n + count in num_set:
                    count += 1

                longest = max(longest, count)

        return longest

use std::collections::HashSet;

struct Solution;

impl Solution {
    fn longest_consecutive(nums: Vec<i32>) -> i32 {
        let set: HashSet<i32> = nums.into_iter().collect();
        let mut longest = 0;

        for &n in &set {
            if !set.contains(&(n - 1)) {
                let mut count = 1;

                while set.contains(&(n + count)) {
                    count += 1;
                }

                longest = longest.max(count);
            }
        }

        longest
    }
}