docs(docs): add new problem documentation pages and source selector component

apps/docs/content/(01-linear-structures)/monotonic-stack/901_online-stock-span.mdx

@@ -0,0 +1,45 @@
+---
+title: '901. Online Stock Span'
+description: Design an algorithm that collects daily price quotes for some stock and returns the span of that stock's price for the current day
+icon: dot
+topics:
+  - { name: "Stack", slug: "stack" }
+  - { name: "Design", slug: "design" }
+  - { name: "Monotonic Stack", slug: "monotonic-stack" }
+  - { name: "Data Stream", slug: "data-stream" }
+issue: "https://github.com/prdlk/leetcode/issues/75"
+sidebar:
+  label: 'Online Stock Span'
+  badge: 'Medium'
+---
+
+### Example 1:
+- Input: ``
+- Output: ``
+- Explanation: Input ["StockSpanner", "next", "next", "next", "next", "next", "next", "next"] `[[]`, `[100]`, `[80]`, `[60]`, `[70]`, `[60]`, `[75]`, [85]] Output [null, `1`, `1`, `1`, `2`, `1`, `4`, 6] Explanation StockSpanner stockSpanner = new StockSpanner(); stockSpanner.next(100); // return `1` stockSpanner.next(80);  // return `1` stockSpanner.next(60);  // return `1` stockSpanner.next(70);  // return `2` stockSpanner.next(60);  // return `1` stockSpanner.next(75);  // return `4`, because the last `4` prices (including today's `price` of `75`) were less than or equal to today's `price`. stockSpanner.next(85);  // return `6`
+
+### Constraints:
+
+- `1 <= price <= 10^5`
+- At most 10^4 calls will be made to next.
+
+## Solution
+
+```py
+class StockSpanner:
+    def __init__(self):
+        self.stack = []
+
+    def next(self, price: int) -> int:
+        ans = 1
+        while self.stack and self.stack[-1][0] <= price:
+            ans += self.stack.pop()[1]
+
+        self.stack.append([price, ans])
+        return ans
+
+
+# Your StockSpanner object will be instantiated and called as such:
+# obj = StockSpanner()
+# param_1 = obj.next(price)
+```

apps/docs/content/(01-linear-structures)/sliding-window/76_minimum-window-substring.mdx

@@ -0,0 +1,46 @@
+---
+title: '76. Minimum Window Substring'
+description: Given two strings s and t of lengths m and n respectively, return the minimum window substring of s such that every character in t (including duplicates) is included in the window. If there is no such substring, return the empty string ""
+icon: dot
+topics:
+  - { name: "Hash Table", slug: "hash-table" }
+  - { name: "String", slug: "string" }
+  - { name: "Sliding Window", slug: "sliding-window" }
+issue: "https://github.com/prdlk/leetcode/issues/57"
+sidebar:
+  label: 'Minimum Window Substring'
+  badge: 'Hard'
+---
+
+::::warning
+Could you find an algorithm that runs in O(m + n) time?
+::::
+
+### Example 1:
+- Input: `s = "ADOBECODEBANC", t = "ABC"`
+- Output: `"BANC"`
+- Explanation: The minimum window substring "BANC" includes 'A', 'B', and 'C' from string `t`.
+
+### Example 2:
+- Input: `s = "a", t = "a"`
+- Output: `"a"`
+- Explanation: The entire string `s` is the minimum window.
+
+### Example 3:
+- Input: `s = "a", t = "aa"`
+- Output: `""`
+- Explanation: Both 'a's from `t` must be included in the window. Since the largest window of `s` only has one 'a', return empty string.
+
+### Constraints:
+
+- `m == s.length`
+- `n == t.length`
+- `1 <= m, n <= 10^5`
+- `s` and `t` consist of uppercase and lowercase English letters.
+
+## Solution
+
+```py
+class Solution:
+    def minWindow(self, s: str, t: str) -> str:
+```

apps/docs/content/(01-linear-structures)/stack/224_basic-calculator.mdx

@@ -0,0 +1,43 @@
+---
+title: '224. Basic Calculator'
+description: Given a string s representing a valid expression, implement a basic calculator to evaluate it, and return the result of the evaluation
+icon: dot
+topics:
+  - { name: "Math", slug: "math" }
+  - { name: "String", slug: "string" }
+  - { name: "Stack", slug: "stack" }
+  - { name: "Recursion", slug: "recursion" }
+issue: "https://github.com/prdlk/leetcode/issues/71"
+sidebar:
+  label: 'Basic Calculator'
+  badge: 'Hard'
+---
+
+### Example 1:
+- Input: `s = "1 + 1"`
+- Output: `2`
+
+### Example 2:
+- Input: `s = " 2-1 + 2 "`
+- Output: `3`
+
+### Example 3:
+- Input: `s = "(1+(4+5+2)-3)+(6+8)"`
+- Output: `23`
+
+### Constraints:
+
+- `1 <= s.length <= 3 * 10^5`
+- `s` consists of digits, '+', '-', '(', ')', and ' '.
+- `s` represents a valid expression.
+- '+' is not used as a unary operation (i.e., "+1" and "+(2 + 3)" is invalid).
+- '-' could be used as a unary operation (i.e., "-1" and "-(2 + 3)" is valid).
+- There will be no two consecutive operators in the input.
+- Every number and running calculation will fit in a signed 32-bit integer.
+
+## Solution
+
+```py
+class Solution:
+    def calculate(self, s: str) -> int:
+```

apps/docs/content/system-design/index.mdx

@@ -0,0 +1,27 @@
+---
+title: System Design
+description: Notes for system design interviews — how to scope a problem, size it, and pick the parts that carry the load.
+icon: network
+sidebar:
+  label: Overview
+---
+
+## How an interview runs
+
+<Steps>
+  <Step title="Requirements">
+    Pin down the functional requirements (what the system does) and the non-functional ones (latency, availability, consistency, scale) before drawing anything.
+  </Step>
+  <Step title="Estimates">
+    Size the traffic, storage and bandwidth with back-of-the-envelope numbers, so later choices have a reason.
+  </Step>
+  <Step title="API and data model">
+    Define the endpoints and the entities they read and write.
+  </Step>
+  <Step title="High-level design">
+    Draw the request path end to end: clients, load balancers, services, caches, stores and queues.
+  </Step>
+  <Step title="Deep dives">
+    Take the hardest part (a hot key, fan-out, a consistency guarantee) and work through its tradeoffs.
+  </Step>
+</Steps>