docs(algorithms, two-pointers): three sum documentation

Author: BrianLusina

algorithms/intervals/insert_interval/README.md

@@ -25,27 +25,27 @@ Return the updated list of intervals.
 
 ## Solution
 
-We first want to create a new list merged to store the merged intervals we will return at the end.
+We first want to create a new list `merged` to store the merged intervals we will return at the end.
 
 This solution operates in 3 phases:
-1. Add all the intervals ending before newInterval starts to merged.
-2. Merge all overlapping intervals with newInterval and add that merged interval to merged.
-3. Add all the intervals starting after newInterval to merged.
+1. Add all the intervals ending before `newInterval` starts to `merged`.
+2. Merge all overlapping intervals with `newInterval` and add that merged interval to `merged`.
+3. Add all the intervals starting after `newInterval` to `merged`.
 
 ### Phase 1
 
-In this phase, we add all the intervals that end before newInterval starts to merged. This involves iterating through the
-intervals list until the current interval no longer ends before newInterval starts (i.e. intervals[i][1] >= newInterval[0]).
+In this phase, we add all the intervals that end before `newInterval` starts to `merged`. This involves iterating through the
+`intervals` list until the current interval no longer ends before `newInterval` starts (i.e. `intervals[i][1] >= newInterval[0]`).
 
 ![Solution 1](./images/solutions/insert_interval_solution_1.png)
 ![Solution 2](./images/solutions/insert_interval_solution_2.png)
 
 ### Phase 2
 
 In this phase, we merge all the intervals that overlap with newInterval together into a single interval by updating 
-newInterval to be the minimum start and maximum end of all the overlapping intervals. This involves iterating through 
-the intervals list until the current interval starts after newInterval ends (i.e. intervals[i][0] > newInterval[1]).
-When that condition is met, we add newInterval to merged and move onto phase 3.
+`newInterval` to be the minimum start and maximum end of all the overlapping intervals. This involves iterating through 
+the intervals list until the current interval starts after `newInterval` ends (i.e. `intervals[i][0] > newInterval[1]`).
+When that condition is met, we add `newInterval` to merged and move onto phase 3.
 
 ![Solution 3](./images/solutions/insert_interval_solution_3.png)
 ![Solution 4](./images/solutions/insert_interval_solution_4.png)

algorithms/two_pointers/three_sum/README.md

@@ -32,3 +32,61 @@ Input: nums = [0,0,0]
 Output: [[0,0,0]]
 Explanation: The only possible triplet sums up to 0.
 ```
+
+## Solution
+
+We can leverage the two-pointer technique to solve this problem by first sorting the array. We can then iterate through
+each element in the array. The problem then reduces to finding two numbers in the rest of the array that sum to the
+negative of the current element, which follows the same logic as the Two Sum (Sorted Array) problem.
+
+![Solution 1](./images/solutions/three_sum_solution_1.png)
+
+Since our first triplet sums to 0, we can add it to our result set.
+
+![Solution 2](./images/solutions/three_sum_solution_2.png)
+![Solution 3](./images/solutions/three_sum_solution_3.png)
+![Solution 4](./images/solutions/three_sum_solution_4.png)
+![Solution 5](./images/solutions/three_sum_solution_5.png)
+![Solution 6](./images/solutions/three_sum_solution_6.png)
+
+### Avoiding Duplicates
+
+As soon as we find a triplet that sums to 0, we can add it to our result set. We then have to move our left and right
+pointers to look for the next triplet while avoiding duplicate triplets. We can do this by moving the left and right
+pointers until they point to different numbers than the ones they were pointing to before.
+Here we move the left pointer once until it reaches the last -1 in the array. Then, we can move both the left and right
+pointers so that they both point to new numbers.
+
+![Solution 7](./images/solutions/three_sum_solution_7.png)
+![Solution 8](./images/solutions/three_sum_solution_8.png)
+
+Here we can do another iteration of the Two Sum problem using the new positions of the left and right pointers.
+
+![Solution 9](./images/solutions/three_sum_solution_9.png)
+![Solution 10](./images/solutions/three_sum_solution_10.png)
+![Solution 11](./images/solutions/three_sum_solution_11.png)
+
+At this point our left and right pointers have crossed, so we can move our iterator to the next number in the array.
+
+### Avoiding Duplicates II
+
+In this case, since the next number in the array is the same as the previous number, we can skip it. We can do this by
+moving our iterator until it points to a new number.
+
+![Solution 12](./images/solutions/three_sum_solution_12.png)
+![Solution 13](./images/solutions/three_sum_solution_13.png)
+![Solution 14](./images/solutions/three_sum_solution_14.png)
+
+And we're ready to start the Two Sum algorithm again, so we reset our left and right pointers, and start the algorithm.
+
+![Solution 15](./images/solutions/three_sum_solution_15.png)
+![Solution 16](./images/solutions/three_sum_solution_16.png)
+![Solution 17](./images/solutions/three_sum_solution_17.png)
+
+### Termination
+
+Our algorithm terminates when i reaches the 3rd to last element in the array (i.e., i < n - 2). This is because we need
+at least 2 more elements after i for left and right to form a triplet.
+
+![Solution 18](./images/solutions/three_sum_solution_18.png)
+![Solution 19](./images/solutions/three_sum_solution_19.png)

algorithms/two_pointers/three_sum/__init__.py

@@ -4,34 +4,48 @@
 def three_sum(nums: List[int]) -> List[List[int]]:
     """
     Complexity Analysis:
+    Ww assume that n is the length of the input array
 
-    Time Complexity: O(nlog(n)) + O(n^2) = O(n^2) the O(nlog(n)) is due to sorting
-    Space Complexity: O(1) as no extra space is taken up
+    Time Complexity: O(nlog(n)) + O(n^2) = O(n^2) the O(nlog(n)) is due to sorting, overall, the time complexity is O(n²).
+    This is due to the nested loops in the algorithm. We perform n iterations of the outer loop, and each iteration
+    takes O(n) time to use the two-pointer technique.
+
+    Space Complexity: O(n²) as no extra space is taken up. We need to store all distinct triplets that sum to 0, which
+    can be at most O(n²) triplets.
 
     Args:
         nums (list): input list of integers
     Return:
         list: list of lists of integers
     """
     result = []
-    # Time Complexity: O(nlog(n))
+    # Time Complexity: O(nlog(n)) sorting in place. This may incur space complexity of O(n) due to Python's timesort
+    # using temporary storage to handle the in place sorting
     nums.sort()
 
     for idx, num in enumerate(nums):
+        # Increment to avoid duplicates
         if idx > 0 and num == nums[idx - 1]:
             continue
 
         left, right = idx + 1, len(nums) - 1
 
         while left < right:
-            sum_ = num + nums[left] + nums[right]
-            if sum_ > 0:
+            total = num + nums[left] + nums[right]
+            if total > 0:
                 right -= 1
-            elif sum_ < 0:
+            elif total < 0:
                 left += 1
             else:
+                # add the triplet
                 result.append([num, nums[left], nums[right]])
-                left += 1
-                while nums[left] == nums[left - 1] and left < right:
+
+                # move the left pointer to avoid duplicates while it is still less than the right
+                while left < right and nums[left] == nums[left + 1]:
                     left += 1
+                while left < right and nums[right] == nums[right - 1]:
+                    right -= 1
+                left += 1
+                right -= 1
+
     return result