docs(docs): add meta files and reorganize topics with updated badges and directory structure

apps/docs/content/(linked-list)/141-linked-list-cycle.mdx

@@ -0,0 +1,74 @@
+---
+title: '141. Linked List Cycle'
+description: Given head, the head of a linked list, determine if the linked list has a cycle in it
+sidebar:
+  label: 'Linked List Cycle'
+  badge: 'Easy'
+---
+
+<Badge variant="accent">Hash Table</Badge>
+
+::::warning
+Can you solve it using O(1) (i.e. constant) memory?
+::::
+
+### Example 1:
+- Input: `head = [3,2,0,-4], pos = 1`
+- Output: `true`
+- Explanation: There is a cycle in the linked list, where the tail connects to the 1st node (0-indexed).
+
+### Example 2:
+- Input: `head = [1,2], pos = 0`
+- Output: `true`
+- Explanation: There is a cycle in the linked list, where the tail connects to the 0th node.
+
+### Example 3:
+- Input: `head = [1], pos = -1`
+- Output: `false`
+- Explanation: There is no cycle in the linked list.
+
+### Constraints:
+
+- The number of the nodes in the list is in the range [0, 10^4].
+- `-10^5 <= Node.val <= 10^5`
+- pos is -1 or a valid index in the linked-list.
+
+## Approach
+
+```mermaid
+flowchart TD
+  S(["hasCycle(head)"]) --> I["fast = slow = head"]
+  I --> W{"fast and fast.next?"}
+  W -- no --> E(["return False — ran off the end, no cycle"])
+  W -- yes --> A["fast = fast.next.next — two steps"]
+  A --> B["slow = slow.next — one step"]
+  B --> Q{"fast is slow?"}
+  Q -- yes --> R(["return True — the gap closed, so it loops"])
+  Q -- no --> W
+```
+
+## Solution
+
+```py
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+
+class Solution:
+    def hasCycle(self, head: Optional[ListNode]) -> bool:
+        fast = slow = head
+
+        while fast and fast.next:
+            fast = fast.next.next
+            slow = slow.next
+            if fast is slow:
+                return True
+        return False
+```
+
+## Explanation
+
+<YouTube id="gBTe7lFR3vc" title="Linked List Cycle - Floyd's Tortoise and Hare - Leetcode 141 - Python" />

apps/docs/content/(linked-list)/2-add-two-numbers.mdx

@@ -1,75 +0,0 @@
----
-title: '2. Add Two Numbers'
-description: You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list
-sidebar:
-  label: 'Add Two Numbers'
-  badge: 'Medium'
----
-
-<Badge variant="accent">Hybrid Structures</Badge>
-
-### Example 1:
-- Input: `l1 = [2,4,3], l2 = [5,6,4]`
-- Output: `[7,0,8]`
-- Explanation: `342 + 465 = 807`.
-
-### Example 2:
-- Input: `l1 = [0], l2 = [0]`
-- Output: `[0]`
-
-### Example 3:
-- Input: `l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]`
-- Output: `[8,9,9,9,0,0,0,1]`
-
-### Constraints:
-
-- The number of nodes in each linked list is in the range [1, 100].
-- `0 <= Node.val <= 9`
-- It is guaranteed that the list represents a number that does not have leading zeros.
-
-## Approach
-
-```mermaid
-flowchart TD
-  S(["addTwoNumbers(l1, l2)"]) --> I["dummy = ListNode(), carry = 0, curr = dummy — dummy.next will be the head"]
-  I --> W{"l1 or l2 or carry?"}
-  W -- no --> E(["return dummy.next"])
-  W -- yes --> A["s = (l1.val if l1 else 0) + (l2.val if l2 else 0) + carry — a missing digit counts as 0"]
-  A --> D["carry, val = divmod(s, 10)"]
-  D --> N["curr.next = ListNode(val), curr = curr.next"]
-  N --> V["l1 = l1.next if l1 else None, l2 = l2.next if l2 else None"]
-  V --> W
-```
-
-## Solution
-
-```py
-# Definition for singly-linked list.
-# class ListNode:
-#     def __init__(self, val=0, next=None):
-#         self.val = val
-#         self.next = next
-class Solution:
-    def addTwoNumbers(
-        self, l1: Optional[ListNode], l2: Optional[ListNode]
-    ) -> Optional[ListNode]:
-
-        dummy = ListNode()
-        carry = 0
-        curr = dummy
-        while l1 or l2 or carry:
-            s = (l1.val if l1 else 0) + (l2.val if l2 else 0) + carry
-            carry, val = divmod(s, 10)
-
-            curr.next = ListNode(val)
-            curr = curr.next
-
-            l1 = l1.next if l1 else None
-            l2 = l2.next if l2 else None
-
-        return dummy.next
-```
-
-## Explanation
-
-<YouTube id="wgFPrzTjm7s" title="Add Two Numbers - Leetcode 2 - Python" />

apps/docs/content/(linked-list)/23-merge-k-sorted-lists.mdx

@@ -1,94 +0,0 @@
----
-title: '23. Merge k Sorted Lists'
-description: You are given an array of k linked-lists lists, each linked-list is sorted in ascending order
-sidebar:
-  label: 'Merge k Sorted Lists'
-  badge: 'Hard'
----
-
-<Badge variant="accent">Heap / Priority Queue</Badge>
-
-### Example 1:
-- Input: `lists = [[1,4,5],[1,3,4],[2,6]]`
-- Output: `[1,1,2,3,4,4,5,6]`
-- Explanation: The linked-lists are: [ 1->4->5, 1->3->4, 2->6 ] merging them into one sorted linked list: 1->1->2->3->4->4->5->6
-
-### Example 2:
-- Input: `lists = []`
-- Output: `[]`
-
-### Example 3:
-- Input: `lists = [[]]`
-- Output: `[]`
-
-### Constraints:
-
-- `k == lists.length`
-- `0 <= k <= 10^4`
-- `0 <= lists[i].length <= 500`
-- `-10^4 <= lists[i][j] <= 10^4`
-- `lists[i]` is sorted in ascending order.
-- The sum of lists[i].length will not exceed 10^4.
-
-## Approach
-
-```mermaid
-flowchart TD
-  S(["mergeKLists(lists)"]) --> I["heap = []"]
-  I --> F{"more i, node in enumerate(lists)?"}
-  F -- yes --> C{"node?"}
-  C -- yes --> P["heapq.heappush(heap, (node.val, i, node)) — i breaks ties so nodes are never compared"]
-  P --> F
-  C -- no --> F
-  F -- no --> D["D = ListNode(), cur = D"]
-  D --> W{"heap?"}
-  W -- no --> E(["return D.next"])
-  W -- yes --> O["val, i, node = heapq.heappop(heap) — the smallest head across all lists"]
-  O --> L["cur.next = node, cur = node, node = node.next"]
-  L --> N{"node?"}
-  N -- yes --> Q["heapq.heappush(heap, (node.val, i, node))"]
-  Q --> W
-  N -- no --> W
-```
-
-## Solution
-
-```py
-# Definition for singly-linked list.
-# class ListNode:
-#     def __init__(self, val=0, next=None):
-#         self.val = val
-#         self.next = next
-import heapq
-
-
-class Solution:
-    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
-        heap = []
-
-        # K log K
-        for i, node in enumerate(lists):
-            if node:
-                heapq.heappush(heap, (node.val, i, node))
-
-        D = ListNode()
-        cur = D
-
-        # n log k
-        while heap:
-            val, i, node = heapq.heappop(heap)
-            cur.next = node
-            cur = node
-            node = node.next
-
-            if node:
-                heapq.heappush(heap, (node.val, i, node))
-
-        # Time: O(N log k)
-        # Space: O(n)
-        return D.next
-```
-
-## Explanation
-
-<YouTube id="q5a5OiGbT6Q" title="Merge K Sorted Lists - Leetcode 23 - Python" />

apps/docs/content/(linked-list)/meta.ts

@@ -0,0 +1,3 @@
+import { defineMeta } from "blume";
+
+export default defineMeta({ title: "Linked List", order: 8 });