Create 14. find all pairs in an array with a given sum.md

Author: ps0305

Machine Coding/14. find all pairs in an array with a given sum.md

@@ -0,0 +1,88 @@
+### Approach 1: Brute Force (Time Complexity: ( O(n^2) ))
+This method iterates over all possible pairs in the array and checks if the sum of the pair equals the target sum.
+```js
+function findPairsBruteForce(arr, targetSum) {
+  const pairs = [];
+  for (let i = 0; i < arr.length; i++) {
+    for (let j = i + 1; j < arr.length; j++) {
+      if (arr[i] + arr[j] === targetSum) {
+        pairs.push([arr[i], arr[j]]);
+      }
+    }
+  }
+  return pairs;
+}
+
+// Example usage
+const array = [1, 2, 3, 4, 5];
+const target = 6;
+console.log(findPairsBruteForce(array, target)); // Output: [[1, 5], [2, 4]]
+```
+### Approach 2: Using a Hash Table (Optimal, Time Complexity: ( O(n) ))
+This method uses a hash table to track numbers needed to reach the target sum. As you iterate through the array, you check if the current number exists in the hash table (indicating you've already encountered the complementary number).
+
+```js
+function findPairsUsingHashTable(arr, targetSum) {
+  const pairs = [];
+  const seen = new Set(); // Use a Set to track visited numbers
+
+  for (const num of arr) {
+    const complement = targetSum - num;
+
+    // Check if the complement exists in the set
+    if (seen.has(complement)) {
+      pairs.push([num, complement]);
+    }
+
+    // Add the current number to the set for future checks
+    seen.add(num);
+  }
+
+  return pairs;
+}
+
+// Example usage
+const array = [1, 2, 3, 4, 5];
+const target = 6;
+console.log(findPairsUsingHashTable(array, target)); // Output: [[4, 2], [5, 1]]
+```
+
+### Approach 3: Two Pointers (Sorted Array, Time Complexity: ( O(n \log n) ) for sorting + ( O(n) ))
+This method works for sorted arrays. It uses two pointers — one starting at the beginning and one at the end of the array. Adjust the pointers based on the sum of the current pair.
+
+```js
+function findPairsTwoPointers(arr, targetSum) {
+  const pairs = [];
+  arr.sort((a, b) => a - b); // Sort the array (required for two-pointer approach)
+
+  let left = 0;
+  let right = arr.length - 1;
+
+  while (left < right) {
+    const sum = arr[left] + arr[right];
+
+    if (sum === targetSum) {
+      pairs.push([arr[left], arr[right]]);
+      left++;
+      right--;
+    } else if (sum < targetSum) {
+      left++; // Move the left pointer up
+    } else {
+      right--; // Move the right pointer down
+    }
+  }
+
+  return pairs;
+}
+
+// Example usage
+const array = [1, 2, 3, 4, 5];
+const target = 6;
+console.log(findPairsTwoPointers(array, target)); // Output: [[1, 5], [2, 4]]
+```
+
+| Approach | Time Complexity | Space Complexity | Notes |
+| :-- | :-- | :-- | :-- |
+| Brute Force | ( O(n^2) ) | ( O(1) ) | Inefficient for large arrays. Good for learning and testing. |
+| Using Hash Table | ( O(n) ) | ( O(n) ) | Fastest approach. Works well for unsorted arrays. |
+| Two Pointers (Sorted) | ( O(n \log n) ) | ( O(1) ) | Requires sorting first. Efficient for sorted arrays. |