add article

Author: neetcode-gh

articles/two-integer-sum.md

@@ -1,5 +1,16 @@
 ## 1. Brute Force
 
+### Intuition
+
+We can check every pair of different elements in the array and return the first pair that sums up to the target. This is the most intuitive approach but it's not the most efficient.
+
+### Algorithm
+
+1. Iterate through the array with two nested loops to check every pair of different elements.
+2. If the sum of the pair equals the target, return the indices of the pair.
+3. If no such pair is found, return an empty array.
+4. There is guaranteed to be exactly one solution, so we will never return an empty array.
+
 ::tabs-start
 
 ```python
@@ -132,6 +143,20 @@ class Solution {
 
 ## 2. Sorting
 
+### Intuition
+
+We can sort the array and use two pointers to find the two numbers that sum up to the target. This is more efficient than the brute force approach. This approach is similar to the one used in <a href="https://neetcode.io/problems/two-integer-sum-ii" target="_blank">Two Sum II</a>.
+
+### Algorithm
+
+1. Create a copy of the array and sort it in ascending order.
+2. Initialize two pointers, one at the beginning and one at the end of the array.
+3. Iterate through the array with the two pointers and check if the sum of the two numbers is equal to the target.
+4. If the sum is equal to the target, return the indices of the two numbers.
+5. If the sum is less than the target, move the left pointer to the right, which will increase the sum.
+6. If the sum is greater than the target, move the right pointer to the left, which will decrease the sum.
+7. There is guaranteed to be exactly one solution, so we will never return an empty array.
+
 ::tabs-start
 
 ```python
@@ -367,6 +392,20 @@ class Solution {
 
 ## 3. Hash Map (Two Pass)
 
+### Intuition
+
+We can use a hash map to store the value and index of each element in the array. Then, we can iterate through the array and check if the complement of the current element exists in the hash map. The complement must be at a different index, because we can't use the same element twice.
+
+By using a hashmap, we can achieve a time complexity of $O(n)$ because the insertion and lookup time of a hashmap is $O(1)$.
+
+### Algorithm
+
+1. Create a hash map to store the value and index of each element in the array.
+2. Iterate through the array and compute the complement of the current element, which is `target - nums[i]`.
+3. Check if the complement exists in the hash map.
+4. If it does, return the indices of the current element and its complement.
+5. If no such pair is found, return an empty array.
+
 ::tabs-start
 
 ```python
@@ -381,6 +420,7 @@ class Solution:
             diff = target - n
             if diff in indices and indices[diff] != i:
                 return [i, indices[diff]]
+        return []
 ```
 
 ```java
@@ -544,6 +584,21 @@ class Solution {
 
 ## 4. Hash Map (One Pass)
 
+### Intuition
+
+We can solve the problem in a single pass by iterating through the array and checking if the complement of the current element exists in the hash map.
+
+If it does, we return the indices of the current element and its complement. If not, we store the current element in the hash map. This guarantees that we will never use the same element twice, but we still check every element in the array.
+
+### Algorithm
+
+1. Create a hash map to store the value and index of each element in the array.
+2. Iterate through the array and compute the complement of the current element, which is `target - nums[i]`.
+3. Check if the complement exists in the hash map.
+4. If it does, return the indices of the current element and its complement.
+5. If no such pair is found, return an empty array.
+
+
 ::tabs-start
 
 ```python