Add contains duplicate algorithm

Author: sudheerj

README.md

@@ -34,8 +34,8 @@ List of Programs related to data structures and algorithms
 
 ### Array
 
-   1. Contains duplicates :  [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/containsDuplicate.js
-    )
+   1. Contains duplicates :  [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/containsDuplicate/containsDuplicate.js) [Playground](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/containsDuplicate/containsDuplicate.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/containsDuplicate/containsDuplicate.md)
+   
    2. Product of array except self: [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/productExceptSelf/productExceptSelf.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/productExceptSelf/productExceptSelf.md)
 
    3. Max sum subarray: [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/maxSubArray.js)

src/java1/algorithms/array/containsDuplicate/ContainsDuplicate.java

@@ -0,0 +1,39 @@
+package containsDuplicate;
+import java.util.*;
+
+class ContainsDuplicate {
+    private static boolean containsDuplicate(int[] nums) {
+        HashSet<Integer> set = new HashSet<>();
+
+        for (int num : nums) {
+            if (set.contains(num)) {
+                return true;
+            }
+            set.add(num);
+        }
+        return false;
+    }
+
+    private static boolean containsDuplicateUsingMap(int[] nums) {
+        HashMap<Integer, Integer> map = new HashMap<>();
+
+        for (int num : nums) {
+            if (map.containsKey(num)) {
+                return true;
+            }
+            map.put(num, 1);
+        }
+        return false;
+    }
+
+    public static void main(String[] args) {
+        int[] nums1 = new int[] { 8, 6, 4, 2, 6 };
+        int[] nums2 = new int[] { 1, 3, 5, 7, 9 };
+
+        System.out.println(containsDuplicate(nums1));
+        System.out.println(containsDuplicate(nums2));
+
+        System.out.println(containsDuplicateUsingMap(nums1));
+        System.out.println(containsDuplicateUsingMap(nums2));
+    }
+}

src/java1/algorithms/array/containsDuplicate/ContainsDuplicate.md

@@ -0,0 +1,32 @@
+**Problem statement:**
+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,1,1,3,3,4,3,2,4,2]
+Output: true
+
+Example 2: 
+
+Input: nums = [1,2,3,4, 5]
+Output: false
+
+**Algorithmic Steps(Approach 1&2)**
+This problem is solved with an optimal solution using either set or map to find out duplicate elements exists or not. The algorithmic approach can be summarized as follows: 
+
+1. Create an empty set or map to store the elements.
+
+2. Iterate an input array using for-each loop.
+
+3. If the current element appears in a set or map, return `true` immediately to indicate duplicate elements exist.
+
+4. Otherwise add the current element to the set or map.
+
+5. After the for loop, return `false` to indicate there are no duplicate elements exist in the array.
+
+
+**Time and Space complexity:**
+This algorithm has a time complexity of O(n), where n is the number of elements in an array. This is because we are traversing the array at most once. 
+
+Here, we use any additional datastructure like set or map. Hence, the space complexity will be O(n).

src/java1/algorithms/array/twoSum2/TwoSum2.java

@@ -1,6 +1,5 @@
 package twoSum2;
-
-import java.util.Arrays;
+import java.util.*;
 
 public class TwoSum2 {
 

src/java1/algorithms/stack/BlancedBrackets.java

@@ -1,4 +1,4 @@
-package java1.datastructures.stack;
+package java1.algorithms.stack;
 
 import java.util.Scanner;
 import java.util.Stack;

src/javascript/algorithms/array/1.containsDuplicate/containsDuplicate.js

@@ -0,0 +1,66 @@
+// Early exit using set:- TC: O(n), SC: O(n)
+function containsDuplicate(nums) {
+    let noDupsSet = new Set();
+    for(const num of nums) {
+        if(noDupsSet.has(num)) {
+            return true;
+        }
+        noDupsSet.add(num);
+    }
+    return false;
+}
+
+// Early exit using object:- TC: O(n), SC: O(n)
+function containsDuplicateUsingObject(nums) {
+    let noDupsObj = {};
+    for(const num of nums) {
+        if(noDupsObj[num]) {
+            return true;
+        }
+        noDupsObj[num] = true;
+    }
+    return false;
+}
+
+//Use Set size:- TC: O(n), SC: O(n)
+function containsDuplicateUsingSize(nums) {
+    return new Set(nums).size !== nums.length;
+}
+
+//Using sort and iteration:- TC: O(n log n), SC: O(n)
+function containsDuplicateUsingSort(nums) {
+    nums.sort((a, b) => a-b);
+    for(let i =1; i< nums.length; i++) {
+        if(nums[i] === nums[i-1]) {
+            return true;
+        }
+    }
+    return false;
+}
+
+//Using naive/Brute force:- TC: O(n^2), SC: O(1)
+function containsDuplicateUsingBruteforce(nums) {
+    for(let i =0; i< nums.length-1; i++) {
+        for (let j = i+1; j < nums.length; j++) {
+            if(nums[i] == nums[j]) {
+                return true;
+            }           
+        }
+    }
+    return false;
+}
+
+console.log("-----Has duplicates----");
+let nums1 = [8, 6, 4, 2, 6];
+console.log(containsDuplicate(nums1));
+console.log(containsDuplicateUsingObject(nums1));
+console.log(containsDuplicateUsingSize(nums1));
+console.log(containsDuplicateUsingSort(nums1));
+console.log(containsDuplicateUsingBruteforce(nums1));
+console.log("-----No duplicates----");
+let nums2 = [1, 3, 5, 7, 9];
+console.log(containsDuplicate(nums2));
+console.log(containsDuplicateUsingObject(nums2));
+console.log(containsDuplicateUsingSize(nums2));
+console.log(containsDuplicateUsingSort(nums2));
+console.log(containsDuplicateUsingBruteforce(nums2));

src/javascript/algorithms/array/1.containsDuplicate/containsDuplicate.md

@@ -0,0 +1,32 @@
+**Problem statement:**
+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,1,1,3,3,4,3,2,4,2]
+Output: true
+
+Example 2: 
+
+Input: nums = [1,2,3,4, 5]
+Output: false
+
+**Algorithmic Steps(Approach 1&2)**
+This problem is solved with an optimal solution using either set or object to find out duplicate elements exists or not. The algorithmic approach can be summarized as follows: 
+
+1. Create an empty set or an object to store the elements.
+
+2. Iterate an input array using for-each loop.
+
+3. If the current element appears in a set or an object, return `true` immediately to indicate duplicate elements exist.
+
+4. Otherwise add the current element to the set or an object.
+
+5. After the for loop, return `false` to indicate there are no duplicate elements exist in the array.
+
+
+**Time and Space complexity:**
+This algorithm has a time complexity of O(n), where n is the number of elements in an array. This is because we are traversing the array at most once. 
+
+Here, we use any additional datastructure like set or object. Hence, the space complexity will be O(n).