docs(docs): add new solution pages, rename guide and solution files, update titles

docs/guides/(data-structures)/02-hash-tables.mdx

@@ -1,5 +1,5 @@
 ---
-title: 'Hashing'
+title: 'Hash Tables'
 description: 'In algorithms, arrays and strings are very similar. They are both ordered collections of elements. The difference is that arrays are mutable, while strings are immutable.'
 ---
 

docs/solutions/121-best-time-to-buy-and-sell-stock.mdx

@@ -0,0 +1,37 @@
+---
+title: '121. Best Time to Buy and Sell Stock'
+description: You are given an array prices where prices[i] is the price of a given stock on the i^th day
+sidebar:
+  badge: 'Easy'
+---
+
+<Badge variant="accent">Sliding Window</Badge>
+
+### Example 1:
+- Input: `prices = [7,1,5,3,6,4]`
+- Output: `5`
+- Explanation: Buy on day `2` (price = `1`) and sell on day `5` (price = `6`), profit = `6-1 = 5`. Note that buying on day `2` and selling on day `1` is not allowed because you must buy before you sell.
+
+### Example 2:
+- Input: `prices = [7,6,4,3,1]`
+- Output: `0`
+- Explanation: In this case, no transactions are done and the max profit = `0`.
+
+### Constraints:
+
+- `1 <= prices.length <= 10^5`
+- `0 <= prices[i] <= 10^4`
+
+## Solution
+
+```py
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        left = min(prices)
+        for right in range(len(prices)):
+            while curr > left:
+                curr -= prices[left]
+                left += 1
+            ans = max(ans, curr)
+        return ans
+```

docs/solutions/33-search-in-rotated-sorted-array.mdx

@@ -0,0 +1,70 @@
+---
+title: '33. Search in Rotated Sorted Array'
+description: There is an integer array nums sorted in ascending order (with distinct values)
+sidebar:
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Binary Search</Badge>
+
+::::warning
+You must write an algorithm with O(log n) runtime complexity.
+::::
+
+### Example 1:
+- Input: `nums = [4,5,6,7,0,1,2], target = 0`
+- Output: `4`
+
+### Example 2:
+- Input: `nums = [4,5,6,7,0,1,2], target = 3`
+- Output: `-1`
+
+### Example 3:
+- Input: `nums = [1], target = 0`
+- Output: `-1`
+
+### Constraints:
+
+- `1 <= nums.length <= 5000`
+- `-10^4 <= nums[i] <= 10^4`
+- All values of `nums` are unique.
+- `nums` is an ascending array that is possibly rotated.
+- `-10^4 <= target <= 10^4`
+
+## Solution
+
+```js
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var search = function(nums, target) {
+  let l = 0, r = nums.length - 1;   
+
+  while (l <= r){
+    let mid = Math.floor((l + r)/2);
+    if (target === nums[mid]) {
+      return mid
+    }
+
+    // Left sorted portion
+    if (nums[l] <= nums[mid]){
+      if (target > nums[mid] || target < nums[l]){
+        l = mid + 1;
+      }else{
+        r = mid - 1;
+      }
+    }
+    // Right sorted portion
+    else{
+      if(target < nums[mid] || target > nums[r]){
+        r = mid - 1; 
+      }else{
+        l = mid + 1;
+      }
+    }
+  }
+  return -1;
+};
+```

docs/solutions/704-binary-search.mdx

@@ -0,0 +1,55 @@
+---
+title: '704. Binary Search'
+description: Given an array of integers nums which is sorted in ascending order, and an integer target, write a function to search target in nums. If target exists, then return its index. Otherwise, return -1
+sidebar:
+  badge: 'Easy'
+---
+
+<Badge variant="accent">Binary Search</Badge>
+
+::::warning
+You must write an algorithm with O(log n) runtime complexity.
+::::
+
+### Example 1:
+- Input: `nums = [-1,0,3,5,9,12], target = 9`
+- Output: `4`
+- Explanation: `9` exists in `nums` and its index is `4`
+
+### Example 2:
+- Input: `nums = [-1,0,3,5,9,12], target = 2`
+- Output: `-1`
+- Explanation: `2` does not exist in `nums` so return `-1`
+
+### Constraints:
+
+- `1 <= nums.length <= 10^4`
+- `-10^4 < nums[i], target < 10^4`
+- All the integers in `nums` are unique.
+- `nums` is sorted in ascending order.
+
+## Solution
+
+```js
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var search = function(nums, target) {
+    let left = 0;
+    let right = nums.length - 1;
+
+    while(left <= right) {
+        const mid = left + Math.floor((right - left) / 2);
+        if (nums[mid] === target) {
+            return mid;
+        } else if(nums[mid] < target){
+            left = mid + 1;
+        } else if (nums[mid] > target) {
+            right = mid - 1;
+        }
+    }
+    return -1;
+};
+```

docs/solutions/875-koko-eating-bananas.mdx

@@ -0,0 +1,61 @@
+---
+title: '875. Koko Eating Bananas'
+description: Koko loves to eat bananas. There are n piles of bananas, the i^th pile has piles[i] bananas. The guards have gone and will come back in h hours
+sidebar:
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Binary Search</Badge>
+
+### Example 1:
+- Input: `piles = [3,6,7,11], h = 8`
+- Output: `4`
+
+### Example 2:
+- Input: `piles = [30,11,23,4,20], h = 5`
+- Output: `30`
+
+### Example 3:
+- Input: `piles = [30,11,23,4,20], h = 6`
+- Output: `23`
+
+### Constraints:
+
+- `1 <= piles.length <= 10^4`
+- `piles.length <= h <= 10^9`
+- `1 <= piles[i] <= 10^9`
+
+## Solution
+
+```js
+/**
+ * @param {number[]} piles
+ * @param {number} h
+ * @return {number}
+ */
+var minEatingSpeed = function(piles, h) {
+  // Function to determine if K works for the H
+   function kWorks(k){
+    let hours = 0;
+    for (let p of piles){
+      hours += Math.ceil(p/k)
+    }
+    return hours <= h;
+  }
+
+  // Setup Binary Search
+  let l = 1;
+  let r = Math.max(...piles);
+
+  // Find the K value which works for H and consumes all bananas
+  while (l < r){
+    const mid = Math.floor((l + r) / 2);
+    if (kWorks(mid)){
+      r = mid;
+    }else{
+      l = mid + 1;
+    }
+  }
+  return l;
+};
+```