217. Contains Duplicate

Easy

Problem Description

Given an integer array nums, return true if any value appears at least twice in the array, and return false if every element is distinct.

Examples

Example 1:
Input: nums = [1,2,3,1]
Output: true

Example 2:
Input: nums = [1,2,3,4]
Output: false

Example 3:
Input: nums = [1,1,1,3,3,4,3,2,4,2]
Output: true
Jump to Solution: Python Java C++ JavaScript C#

Python Solution


def containsDuplicate(nums: List[int]) -> bool:
    return len(nums) != len(set(nums))

Alternative Solution:


def containsDuplicate(nums: List[int]) -> bool:
    seen = set()
    for num in nums:
        if num in seen:
            return True
        seen.add(num)
    return False

Java Solution


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

C++ Solution


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

JavaScript Solution


/**
 * @param {number[]} nums
 * @return {boolean}
 */
var containsDuplicate = function(nums) {
    return new Set(nums).size !== nums.length;

Alternative Solution:


var containsDuplicate = function(nums) {
    const seen = new Set();
    for (const num of nums) {
        if (seen.has(num)) {
            return true;
        }
        seen.add(num);
    }
    return false;
};

C# Solution


public class Solution {
    public bool ContainsDuplicate(int[] nums) {
        HashSet seen = new HashSet();
        foreach (int num in nums) {
            if (!seen.Add(num)) {
                return true;
            }
        }
        return false;
    }
}

Complexity Analysis

Solution Explanation

There are two main approaches to solve this problem:

Key Points

Alternative Approaches

Edge Cases