]+src=["']([^"']+)["'][^>]*>/gi;
+ const imageUrls: string[] = [];
+ let imageMatch;
+ while ((imageMatch = imageUrlRegex.exec(content)) !== null) {
+ const imageUrl = imageMatch[1];
+ // Only include images that look like LeetCode example images
+ // Usually they're hosted on LeetCode CDN or are relative paths
+ if (imageUrl && !imageUrl.startsWith('data:')) {
+ imageUrls.push(imageUrl);
+ }
+ }
+
// Extract examples
const examples: Array<{
input: string;
output: string;
explanation?: string;
+ imageUrl?: string;
}> = [];
- const exampleRegex =
- /\*{0,2}Example \d+:\*{0,2}\s*\n?\*{0,2}Input:\*{0,2}\s*([^\n]+?)\s*\n?\*{0,2}Output:\*{0,2}\s*([^\n]+?)(?:\s*\n?\*{0,2}Explanation:\*{0,2}\s*([^\n]+?))?(?=\*{0,2}Example|\n\n|$)/gis;
- let match;
- while ((match = exampleRegex.exec(cleanContent)) !== null) {
- examples.push({
- input: this.normalizeWhitespace(match[1].trim()),
- output: this.normalizeWhitespace(match[2].trim()),
- explanation: match[3]
- ? this.normalizeWhitespace(match[3].trim())
- : undefined,
- });
+
+ // Try multiple regex patterns to handle different markdown formats from turndown
+ // Pattern 1: Standard format with bold markers
+ // Stop at next Example, Constraints, Follow-up, or end of content
+ const exampleRegex1 =
+ /\*{0,2}Example\s+(\d+):\*{0,2}[\s\S]*?\*{0,2}Input:\*{0,2}\s*\n?\s*(.+?)\s*\n\s*\*{0,2}Output:\*{0,2}\s*\n?\s*(.+?)(?:\s*\n\s*\*{0,2}Explanation:\*{0,2}\s*\n?\s*(.+?))?(?=\s*\n\s*\*{0,2}(?:Example\s+\d+|Constraints?|Follow-up):|$)/gis;
+
+ // Pattern 2: Without bold markers (plain text)
+ // Stop at next Example, Constraints, Follow-up, or end of content
+ const exampleRegex2 =
+ /Example\s+(\d+):[\s\S]*?Input:\s*\n?\s*(.+?)\s*\n\s*Output:\s*\n?\s*(.+?)(?:\s*\n\s*Explanation:\s*\n?\s*(.+?))?(?=\s*\n\s*(?:Example\s+\d+|Constraints?|Follow-up):|$)/gis;
+
+ // Pattern 3: More flexible spacing
+ // Stop at next Example, Constraints, Follow-up, or end of content
+ const exampleRegex3 =
+ /\*{0,2}Example\s+(\d+)\*{0,2}[\s\S]*?\*{0,2}Input\*{0,2}[\s\S]*?([^\n]+(?:[\s\S]+?)?)\s*\n\s*\*{0,2}Output\*{0,2}[\s\S]*?([^\n]+(?:[\s\S]+?)?)(?:\s*\n\s*\*{0,2}Explanation\*{0,2}[\s\S]*?([^\n]+(?:[\s\S]+?)?))?(?=\s*\n\s*\*{0,2}(?:Example\s+\d+|Constraints?|Follow-up):|$)/gis;
+
+ const patterns = [exampleRegex1, exampleRegex2, exampleRegex3];
+
+ for (const pattern of patterns) {
+ let match;
+ pattern.lastIndex = 0; // Reset regex
+ while ((match = pattern.exec(cleanContent)) !== null) {
+ let input =
+ match[2]?.trim().replace(/\n\s*/g, ' ').replace(/\s+/g, ' ') || '';
+ let output =
+ match[3]?.trim().replace(/\n\s*/g, ' ').replace(/\s+/g, ' ') || '';
+ let explanation = match[4]
+ ?.trim()
+ .replace(/\n\s*/g, ' ')
+ .replace(/\s+/g, ' ');
+
+ // Remove any section headers that might have been captured (Constraints, Follow-up, etc.)
+ const sectionHeaderRegex =
+ /\s*\*{0,2}(?:Constraints?|Follow-up):\s*.*$/i;
+ input = input.replace(sectionHeaderRegex, '').trim();
+ output = output.replace(sectionHeaderRegex, '').trim();
+ explanation = explanation?.replace(sectionHeaderRegex, '').trim();
+
+ // Only add if we have valid input and output
+ if (input && output) {
+ // Try to match image URL to this example (by index)
+ const imageUrl = imageUrls[examples.length] || undefined;
+ examples.push({
+ input: this.normalizeWhitespace(input),
+ output: this.normalizeWhitespace(output),
+ explanation: explanation
+ ? this.normalizeWhitespace(explanation)
+ : undefined,
+ imageUrl: imageUrl,
+ });
+ }
+ }
+
+ // If we found examples, break (don't try other patterns)
+ if (examples.length > 0) {
+ break;
+ }
+ }
+
+ // Fallback: parse examples directly from HTML if markdown parsing failed
+ if (examples.length === 0) {
+ // LeetCode often uses tags with Input: and Output:
+ const htmlExampleRegex =
+ /]*>[\s\S]*?]*>Input:\s*<\/strong>\s*([^<]+)[\s\S]*?]*>Output:\s*<\/strong>\s*([^<]+)(?:[\s\S]*?]*>Explanation:\s*<\/strong>\s*([^<]+))?[\s\S]*?<\/pre>/gi;
+ let htmlMatch;
+ while ((htmlMatch = htmlExampleRegex.exec(content)) !== null) {
+ const input =
+ htmlMatch[1]
+ ?.trim()
+ .replace(/ /g, ' ')
+ .replace(/\s+/g, ' ') || '';
+ const output =
+ htmlMatch[2]
+ ?.trim()
+ .replace(/ /g, ' ')
+ .replace(/\s+/g, ' ') || '';
+ const explanation = htmlMatch[3]
+ ?.trim()
+ .replace(/ /g, ' ')
+ .replace(/\s+/g, ' ');
+
+ if (input && output) {
+ // Try to match image URL to this example (by index)
+ const imageUrl = imageUrls[examples.length] || undefined;
+ examples.push({
+ input: this.normalizeWhitespace(input),
+ output: this.normalizeWhitespace(output),
+ explanation: explanation
+ ? this.normalizeWhitespace(explanation)
+ : undefined,
+ imageUrl: imageUrl,
+ });
+ }
+ }
}
// Extract main description (everything before constraints, examples, or follow-up)
@@ -465,7 +569,7 @@ ${content
.examples!.map(
(example, index) =>
` * ${index + 1}. Input: ${example.input}
- * Output: ${example.output}${example.explanation ? `\n * Explanation: ${example.explanation}` : ''}`
+ * Output: ${example.output}${example.explanation ? `\n * Explanation: ${example.explanation}` : ''}${example.imageUrl ? `\n * Image: ${example.imageUrl}` : ''}`
)
.join('\n')}`
: ' *';
@@ -533,32 +637,6 @@ export const solutions = [solution];
`;
}
- private inferOutputType(
- examples: Array<{ output: string }> | undefined
- ): string {
- if (examples?.length === 0) return 'any';
-
- try {
- const firstOutput = JSON.parse(examples![0].output);
-
- if (Array.isArray(firstOutput)) {
- if (firstOutput.length === 0) return 'any[]';
- if (typeof firstOutput[0] === 'number') return 'number[]';
- if (typeof firstOutput[0] === 'string') return 'string[]';
- if (typeof firstOutput[0] === 'boolean') return 'boolean[]';
- return 'any[]';
- }
-
- if (typeof firstOutput === 'number') return 'number';
- if (typeof firstOutput === 'string') return 'string';
- if (typeof firstOutput === 'boolean') return 'boolean';
-
- return 'any';
- } catch {
- return 'any';
- }
- }
-
private generateZodInputTypes(metaData: string): string {
try {
const parsed = JSON.parse(metaData);
diff --git a/problems/0104-maximum-depth-of-binary-tree.ts b/problems/0104-maximum-depth-of-binary-tree.ts
new file mode 100644
index 0000000..9297c8e
--- /dev/null
+++ b/problems/0104-maximum-depth-of-binary-tree.ts
@@ -0,0 +1,141 @@
+/**
+ * 0104. Maximum Depth of Binary Tree
+ *
+ * Difficulty: easy
+ * Tags: tree, depth-first-search, breadth-first-search, binary-tree
+ *
+ * Description:
+ * Given the `root` of a binary tree, return _its maximum depth_.
+ *
+ * A binary tree's **maximum depth** is the number of nodes along the longest path from the root node down to the farthest leaf node.
+ *
+ * Examples:
+ * 1. Input: root = \[3,9,20,null,null,15,7\]
+ * Output: 3
+ * Image: https://assets.leetcode.com/uploads/2020/11/26/tmp-tree.jpg
+ * 2. Input: root = \[1,null,2\]
+ * Output: 2
+ *
+ * Constraints:
+ * - The number of nodes in the tree is in the range `[0, 10^4]`.
+ * - `-100 <= Node.val <= 100`
+ *
+ */
+import { z } from 'zod';
+import type { TestCase } from '../packages/src/types.js';
+
+export class TreeNode {
+ val: number;
+ left: TreeNode | null;
+ right: TreeNode | null;
+ constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ this.val = val ?? 0;
+ this.left = left ?? null;
+ this.right = right ?? null;
+ }
+}
+
+export const TreeNodeSchema = z
+ .instanceof(TreeNode)
+ .check(
+ z.property('val', z.number()),
+ z.property('left', z.lazy(() => TreeNodeSchema).nullable()),
+ z.property('right', z.lazy(() => TreeNodeSchema).nullable())
+ );
+
+export const SolutionSchema = z.function({
+ input: [TreeNodeSchema.nullable()],
+ output: z.number(),
+});
+
+export type Solution = z.infer;
+
+const arrayToTreeNode = (array: (number | null)[]): TreeNode => {
+ if (array.length === 0) {
+ throw new Error('Array is empty');
+ }
+ const root = new TreeNode(array[0]!);
+ const queue: (TreeNode | null)[] = [root];
+
+ for (let index = 1; index < array.length + 1; index += 2) {
+ const node = queue.shift();
+ if (node) {
+ node.left = array[index] ? new TreeNode(array[index]!) : null;
+ queue.push(node.left);
+ if (index + 1 < array.length) {
+ node.right = array[index + 1] ? new TreeNode(array[index + 1]!) : null;
+ queue.push(node.right);
+ }
+ }
+ }
+ return root;
+};
+
+export const cases: TestCase[] = [
+ {
+ input: [arrayToTreeNode([3, 9, 20, null, null, 15, 7])],
+ expected: 3,
+ name: 'Example 1',
+ },
+ {
+ input: [arrayToTreeNode([1, null, 2])],
+ expected: 2,
+ name: 'Example 2',
+ },
+];
+
+/**
+ * Iterative Solution
+ * @utilities: TreeNode
+ * Approach:
+ * - Use a stack to traverse the tree iteratively
+ * - Track the current level and the maximum level
+ * - Return the maximum level
+ * Time Complexity: O(n)
+ * Space Complexity: O(h) where h is the height of the tree
+ */
+export const iterativeSolution = SolutionSchema.implement((root) => {
+ if (!root) {
+ return 0;
+ }
+ const stack: [TreeNode, number][] = [[root, 1]];
+ let node: TreeNode | null = root;
+ let maxLevel = 0;
+ let currentLevel = 1;
+ while (stack.length > 0 || node !== null) {
+ while (node !== null) {
+ stack.push([node, currentLevel]);
+ node = node.left;
+ currentLevel += 1;
+ }
+
+ const [currentNode, level] = stack.pop() as [TreeNode, number];
+ maxLevel = Math.max(maxLevel, level);
+
+ node = currentNode.right;
+ currentLevel = level + 1;
+ }
+
+ return maxLevel;
+});
+
+/**
+ * Recursive Solution
+ * @utilities: TreeNode
+ * Approach:
+ * - Use a recursive function to traverse the tree
+ * - Return the maximum depth of the left and right subtrees
+ * - Return the maximum depth of the tree
+ * Time Complexity: O(n)
+ * Space Complexity: O(h) where h is the height of the tree
+ */
+export const recursiveSolution = SolutionSchema.implement((root) => {
+ if (!root) {
+ return 0;
+ }
+ return (
+ 1 + Math.max(recursiveSolution(root.left), recursiveSolution(root.right))
+ );
+});
+
+export const solutions = [iterativeSolution, recursiveSolution];
![\"Example](\"https://assets.leetcode.com/uploads/2020/11/26/tmp-tree.jpg\")