Update contains duplicate markdown

Author: sudheerj

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

@@ -1,32 +1,41 @@
-**Problem statement:**
+# **Contains Duplicate**
+
+## **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
+## **Examples**
 
-Example 2: 
+### Example 1:
+- **Input**: `nums = [1, 1, 1, 3, 3, 4, 3, 2, 4, 2]`  
+- **Output**: `true`  
 
-Input: nums = [1,2,3,4, 5]
-Output: false
+### 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.
+## **Algorithmic Approach (Using Set or Object)**
 
-2. Iterate an input array using for-each loop.
+This problem can be solved optimally using either a `Set` or an `Object` to detect duplicate elements. Below is the step-by-step approach:
 
-3. If the current element appears in a set or an object, return `true` immediately to indicate duplicate elements exist.
+1. Create an empty `Set` or `Object` to store elements from the array.
+2. Iterate through the input array using a loop.
+3. For each element:
+   - If the current element already exists in the `Set` or `Object`, return `true` immediately (indicating duplicates exist).
+   - Otherwise, add the current element to the `Set` or `Object`.
+4. If the loop completes without finding any duplicates, return `false`.
 
-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**
 
+- **Time Complexity**:  
+  The time complexity of this algorithm is **O(n)**, where `n` is the number of elements in the array. This is because we iterate through the array once, and operations like adding or checking membership in a `Set` or `Object` are constant time on average.
 
-**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. 
+- **Space Complexity**:  
+  The space complexity is **O(n)** as we use an additional data structure (`Set` or `Object`) to store elements from the array.
 
-Here, we use any additional datastructure like set or object. Hence, the space complexity will be O(n).
+---