Question

Formatted question description: https://leetcode.ca/all/217.html

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.

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


Constraints:

• 1 <= nums.length <= 105
• -109 <= nums[i] <= 109

Algorithm

Use a hash table, traverse the entire array, if the hash table exists, return false, if not, put it into the hash table.

Or, sort the array first, and then compare whether two adjacent numbers are equal, the time complexity depends on the sorting method.

Code

• import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public class Contains_Duplicate {

public class Solution_extraSpace {
public boolean containsDuplicate(int[] nums) {
Set<Integer> set = new HashSet<>();
for (int i : nums) {
if (!set.add(i))// if there is same
return true;
}
return false;
}
}

public class Solution_extraOps {
public boolean containsDuplicate(int[] nums) {
Arrays.sort(nums);
for (int i = 1; i < nums.length; ++i) {
if (nums[i] == nums[i - 1])
return true;
}
return false;
}
}
}

############

class Solution {
public boolean containsDuplicate(int[] nums) {
Set<Integer> s = new HashSet<>();
for (int num : nums) {
return true;
}
}
return false;
}
}

• // OJ: https://leetcode.com/problems/contains-duplicate/
// Time: O(N)
// Space: O(N)
class Solution {
public:
bool containsDuplicate(vector<int>& A) {
unordered_set<int> s(begin(A), end(A));
return s.size() != A.size();
}
};

• class Solution:
def containsDuplicate(self, nums: List[int]) -> bool:
return len(set(nums)) < len(nums)

############

class Solution(object):
def containsDuplicate(self, nums):
"""
:type nums: List[int]
:rtype: bool
"""
nums.sort()
for i in range(0, len(nums) - 1):
if nums[i] == nums[i + 1]:
return True
return False


• func containsDuplicate(nums []int) bool {
s := map[int]bool{}
for _, v := range nums {
if s[v] {
return true
}
s[v] = true
}
return false
}

• function containsDuplicate(nums: number[]): boolean {
return new Set<number>(nums).size !== nums.length;
}


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


• class Solution {
/**
* @param Integer[] $nums * @return Boolean */ function containsDuplicate($nums) {
$numsUnique = array_unique($nums);
return count($nums) != count($numsUnique);
}
}

• public class Solution {
public bool ContainsDuplicate(int[] nums) {
return nums.Distinct().Count() < nums.Length;
}
}

• use std::collections::HashSet;
impl Solution {
pub fn contains_duplicate(nums: Vec<i32>) -> bool {
nums.iter().collect::<HashSet<&i32>>().len() != nums.len()
}
}