docs(docs): add MDX documentation for problems 153 and 35

apps/docs/content/(array)/153-find-minimum-in-rotated-sorted-array.mdx

@@ -0,0 +1,55 @@
+---
+title: '153. Find Minimum in Rotated Sorted Array'
+description: 'Suppose an array of length n sorted in ascending order is rotated between 1 and n times. For example, the array nums = [0,1,2,4,5,6,7] might become:'
+sidebar:
+  label: 'Find Minimum in Rotated Sorted Array'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Binary Search</Badge>
+
+::::warning
+Notice that rotating an array [a[0], a[1], a[2], ..., a[n-1]] 1 time results in the array [a[n-1], a[0], a[1], a[2], ..., a[n-2]].
+::::
+
+### Example 1:
+- Input: `nums = [3,4,5,1,2]`
+- Output: `1`
+- Explanation: The original array was `[1,2,3,4,5]` rotated `3` times.
+
+### Example 2:
+- Input: `nums = [4,5,6,7,0,1,2]`
+- Output: `0`
+- Explanation: The original array was `[0,1,2,4,5,6,7]` and it was rotated `4` times.
+
+### Example 3:
+- Input: `nums = [11,13,15,17]`
+- Output: `11`
+- Explanation: The original array was `[11,13,15,17]` and it was rotated `4` times.
+
+### Constraints:
+
+- `n == nums.length`
+- `1 <= n <= 5000`
+- `-5000 <= nums[i] <= 5000`
+- All the integers of `nums` are unique.
+- `nums` is sorted and rotated between 1 and `n` times.
+
+## Solution
+
+```py
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+        l, r = 0, len(nums) - 1
+        lowest_index = -1
+
+        while l <= r:
+            m = (l + r) // 2
+            if nums[m] <= nums[-1]:
+                lowest_index = m
+                r = m - 1
+            else:
+                l = m + 1
+
+        return nums[lowest_index]
+```

apps/docs/content/(array)/35-search-insert-position.mdx

@@ -0,0 +1,51 @@
+---
+title: '35. Search Insert Position'
+description: Given a sorted array of distinct integers and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order
+sidebar:
+  label: 'Search Insert Position'
+  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,3,5,6], target = 5`
+- Output: `2`
+
+### Example 2:
+- Input: `nums = [1,3,5,6], target = 2`
+- Output: `1`
+
+### Example 3:
+- Input: `nums = [1,3,5,6], target = 7`
+- Output: `4`
+
+### Constraints:
+
+- `1 <= nums.length <= 10^4`
+- `-10^4 <= nums[i] <= 10^4`
+- `nums` contains distinct values sorted in ascending order.
+- `-10^4 <= target <= 10^4`
+
+## Solution
+
+```py
+class Solution:
+    def searchInsert(self, nums: List[int], target: int) -> int:
+        l, r = 0, len(nums) - 1
+
+        while l <= r:
+            m = (l + r) // 2
+            if nums[m] == target:
+                return m
+            elif nums[m] < target:
+                l = m + 1
+            elif nums[m] > target:
+                r = m - 1
+
+        return (l + r) // 2 + 1
+```