Contains Duplicate — HashSet O(n) Solution with All Languages [Easy]

Input: [1, 2, 3, 1]  → true  (1 appears twice)
Input: [1, 2, 3, 4]  → false (all distinct)
Input: [1, 1, 1, 3, 3, 4, 3, 2, 4, 2] → true

#include <stdbool.h>
#include <stdlib.h>
#include <string.h>

// Comparison for qsort
int cmp(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

bool containsDuplicate(int* nums, int numsSize) {
    // Sort approach O(n log n)
    qsort(nums, numsSize, sizeof(int), cmp);
    for (int i = 1; i < numsSize; i++) {
        if (nums[i] == nums[i-1]) return true;
    }
    return false;
}

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

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_set<int> seen;
        for (int num : nums) {
            if (seen.count(num)) return true;
            seen.insert(num);
        }
        return false;
    }
};

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

class Solution {
    public boolean containsDuplicate(int[] nums) {
        Set<Integer> seen = new HashSet<>();
        for (int num : nums) {
            if (!seen.add(num)) return true; // add() returns false if already present
        }
        return false;
    }
}

function containsDuplicate(nums) {
    const seen = new Set();
    for (const num of nums) {
        if (seen.has(num)) return true;
        seen.add(num);
    }
    return false;
    // One-liner: return nums.length !== new Set(nums).size;
}

from typing import List

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        return len(nums) != len(set(nums))
        # Or explicit:
        # seen = set()
        # for num in nums:
        #     if num in seen: return True
        #     seen.add(num)
        # return False

def containsNearbyDuplicate(nums, k):
    window = set()
    for i, num in enumerate(nums):
        if num in window: return True
        window.add(num)
        if len(window) > k: window.remove(nums[i - k])
    return False