Contains Duplicate

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

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

                                            
class Solution(object):
    def containsDuplicate(self, nums):
        """
        :type nums: List[int]
        :rtype: bool
        """
        num_set = set()
        
        for num in nums:
            if num in num_set:
                return True
            num_set.add(num)
        
        return False

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

                                            
/**
 * @param {number[]} nums
 * @return {boolean}
 */
const containsDuplicate = (nums) => {
    let seen = new Set();
    for (let num of nums) {
        if (seen.has(num)) {
            return true;
        }
        seen.add(num);
    }
    return false;
};

                                            
function containsDuplicate(nums: number[]): boolean {
    const set = new Set<number>();
    for (const num of nums) {
        if (set.has(num)) {
            return true;
        }
        set.add(num);
    }
    return false;
};

                                            
class Solution {
    /**
     * @param Integer[] $nums
     * @return Boolean
     */
    function containsDuplicate($nums) {
        $uniqueNums = array_unique($nums);
        if (count($nums) == count($uniqueNums)) {
            return false;
        } else {
            return true;
        }
    }
}

                                            
class Solution {
    func containsDuplicate(_ nums: [Int]) -> Bool {
        var set = Set<Int>()
        
        for num in nums {
            if set.contains(num) {
                return true
            }
            set.insert(num)
        }
        
        return false
    }
}

                                            
class Solution {
    fun containsDuplicate(nums: IntArray): Boolean {
        val set = HashSet<Int>()
        for (num in nums) {
            if (set.contains(num)) {
                return true
            } else {
                set.add(num)
            }
        }
        return false
    }
}

                                            
class Solution {
  bool containsDuplicate(List<int> nums) {
    Set<int> set = Set<int>();
    for (int num in nums) {
      if (set.contains(num)) {
        return true;
      } else {
        set.add(num);
      }
    }
    return false;
  }
}

                                            
func containsDuplicate(nums []int) bool {
    numMap := make(map[int]bool)
    
    for _, num := range nums {
        if numMap[num] {
            return true
        }
        numMap[num] = true
    }
    
    return false
}

                                            
# @param {Integer[]} nums
# @return {Boolean}
def contains_duplicate(nums)
    nums.uniq.length != nums.length
end

                                            
object Solution {
    def containsDuplicate(nums: Array[Int]): Boolean = {
        nums.length != nums.toSet.size
    }
}

                                            
impl Solution {
    pub fn contains_duplicate(nums: Vec<i32>) -> bool {
        use std::collections::HashSet;
        
        let mut set = HashSet::new();
        
        for num in nums {
            if !set.insert(num) {
                return true;
            }
        }
        
        false
    }
}

                                            
(define/contract (contains-duplicate nums)
  (-> (listof exact-integer?) boolean?)
  
  (not (=
        (length nums)
        (length (remove-duplicates nums))
       )
  )
)

                                            
-spec contains_duplicate(Nums :: [integer()]) -> 
    boolean().
contains_duplicate(Nums) ->
    length(lists:usort(Nums)) /= length(Nums).

                                            
defmodule Solution do
  @spec contains_duplicate(nums :: [integer]) :: boolean
  def contains_duplicate(nums) do
    Enum.count(nums) != Enum.uniq(nums) |> length()
  end
end

To solve this coding challenge, you need to determine whether there are any duplicate elements in a given array of integers. If the array contains at least one duplicate element, the function should return

true

; otherwise, it should return

false

Explanation

To solve this problem, one efficient approach is to use a set data structure. Sets are particularly useful in this context because they automatically handle duplicates—any attempt to add an element that already exists in the set will be ignored. Here is a step-by-step explanation of the approach:

Initialize an Empty Set : Start by creating an empty set. This set will keep track of all unique elements encountered as we iterate through the array.
Iterate Through the Array : Loop through each element in the array.
Check for Duplicates : For each element, check if it already exists in the set.

If it exists, this means the array contains a duplicate, and you can return
true

immediately.
If it does not exist, add the element to the set.

Return Result : If the loop completes without finding any duplicates, return
false

.

Detailed Steps in Pseudocode

Here's the pseudocode with detailed comments explaining each step:

                                            
function containsDuplicate(integerArray nums):
# Step 1: Initialize an empty set to track unique elements
set uniqueElements = {}

# Step 2: Iterate through each element in the input array
for integer element in nums:
# Step 3: Check if the element is already in the set
if element in uniqueElements:
# Duplicate found, return true
return true

# Step 4: Add the element to the set since it's not a duplicate
uniqueElements.add(element)

# Step 5: No duplicates were found, return false
return false

Step-by-Step Explanation

Initialization :

set uniqueElements = {}

: Here, we initialize an empty set named
uniqueElements

which will store each unique element from the input array as we encounter them.

Iteration :

for integer element in nums

: This for-loop goes through each integer in the array
nums

.

Duplicate Check :

if element in uniqueElements

: Inside the for-loop, for each integer
element

, we check if it is already present in the
uniqueElements

set.

return true

: If the element is found in the set, it means we have encountered a duplicate. We immediately return
true

.

Add to Set :

uniqueElements.add(element)

: If the element is not found in the set, we add it to the
uniqueElements

set. This step ensures that we keep track of the elements we have already seen.

Return False :

return false

: If the loop finishes without returning
true

, it means no duplicates were found in the array. Therefore, we return
false

.

This approach is efficient with a time complexity of O(n), where n is the number of elements in the array. The space complexity is also O(n) in the worst case, when all elements are unique. By following these steps, you can effectively determine if an array contains any duplicate elements.