docs: rename category folders to remove parentheses and update heap meta title

apps/docs/content/binary-search/33-search-in-rotated-sorted-array.mdx

@@ -0,0 +1,98 @@
+---
+title: '33. Search in Rotated Sorted Array'
+description: There is an integer array nums sorted in ascending order (with distinct values)
+sidebar:
+  label: 'Search in Rotated Sorted Array'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Array</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`
+
+## Approach
+
+```mermaid
+flowchart TD
+  S(["search(nums, target)"]) --> I["l = 0, r = n - 1"]
+  I --> W{"l <= r?"}
+  W -- no --> E(["return -1"])
+  W -- yes --> M["mid = floor((l + r) / 2)"]
+  M --> F{"nums[mid] == target?"}
+  F -- yes --> R(["return mid"])
+  F -- no --> H{"nums[l] <= nums[mid]? — left half sorted"}
+  H -- yes --> A{"target outside [nums[l], nums[mid]]?"}
+  A -- yes --> A1["l = mid + 1 — search the right half"]
+  A -- no --> A2["r = mid - 1"]
+  H -- no --> B{"target outside [nums[mid], nums[r]]?"}
+  B -- yes --> B1["r = mid - 1 — search the left half"]
+  B -- no --> B2["l = mid + 1"]
+  A1 --> W
+  A2 --> W
+  B1 --> W
+  B2 --> W
+```
+
+## 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;
+};
+```
+
+## Explanation
+
+<YouTube id="U8XENwh8Oy8" title="Search in rotated sorted array - Leetcode 33 - Python" />