feat: implemented cookiecutter template

Author: wislertt

.templates/leetcode/.example/examples/basic.json5

@@ -18,6 +18,7 @@
     "constraints": "- 2 <= nums.length <= 10^4\n- -10^9 <= nums[i] <= 10^9\n- -10^9 <= target <= 10^9\n- Only one valid answer exists.",
     "parameters": "nums: list[int], target: int",
     "return_type": "list[int]",
+    "dummy_return": "[]",
     "imports": "",
     "test_setup": "",
     "test_logging": "",

.templates/leetcode/.example/examples/tree.json5

@@ -0,0 +1,77 @@
+# LeetCode Problem Template Examples
+
+These JSON5 files serve as reference templates for creating new LeetCode problems. Each template is designed to help LLMs parse raw problem text from leetcode.com into the correct JSON format.
+
+## Template Types
+
+### 1. `basic.json5` - Array/Number Problems
+
+- **Use for**: Array manipulation, hash table, basic algorithms
+- **Examples**: Two Sum, Contains Duplicate, Product of Array Except Self
+- **Key features**: Simple parameters, basic return types, no special imports
+
+### 2. `tree.json5` - Binary Tree Problems
+
+- **Use for**: Binary tree traversal, tree manipulation, tree construction
+- **Examples**: Invert Binary Tree, Maximum Depth, Validate BST
+- **Key features**: TreeNode import, array-to-tree conversion, tree-specific logging
+
+### 3. `linked_list.json5` - Linked List Problems
+
+- **Use for**: Singly linked list manipulation, list reversal, merging
+- **Examples**: Reverse Linked List, Merge Two Lists, Remove Nth Node
+- **Key features**: ListNode import, array-to-list conversion, multiple parameters
+
+### 4. `string.json5` - String Problems
+
+- **Use for**: String manipulation, validation, parsing
+- **Examples**: Valid Parentheses, Longest Substring, Palindrome Check
+- **Key features**: String parameters, boolean returns, validation patterns
+
+### 5. `matrix.json5` - 2D Array/Matrix Problems
+
+- **Use for**: Matrix operations, 2D array manipulation, grid problems
+- **Examples**: Rotate Image, Spiral Matrix, Set Matrix Zeroes
+- **Key features**: 2D list types, in-place modifications, deep copy for testing
+
+## Usage Instructions
+
+1. **Choose the appropriate template** based on the problem's primary data structure
+2. **Copy the template structure** and fill in the specific problem details
+3. **Follow the comments** for guidance on each field
+4. **Use modern Python syntax** (e.g., `list[int]` instead of `List[int]`)
+5. **Test the generated JSON** with `make q-gen QUESTION=your_problem`
+
+## Key Conventions
+
+- **Naming**: Use snake_case for `question_name` and `method_name`, PascalCase for `class_name`
+- **Types**: Use modern Python type hints (`list[int]`, `TreeNode | None`)
+- **Parameters**: Match the exact parameter names from the LeetCode method signature
+- **Test Cases**: Use the same data format as the examples (arrays for trees/lists)
+- **Imports**: Only include necessary imports (`TreeNode`, `ListNode`, etc.)
+
+## Common Patterns
+
+### Return Types & Dummy Returns
+
+- `bool` → `"False"`
+- `int` → `"0"`
+- `str` → `"\"\""`
+- `list[int]` → `"[]"`
+- `TreeNode | None` → `"None"`
+- `ListNode | None` → `"None"`
+
+### Test Parameter Naming
+
+- **Basic problems**: `param1, param2, expected`
+- **Tree problems**: `root_list, expected_list` (converts arrays to TreeNode)
+- **Linked List problems**: `head_list, param2, expected_list` (converts arrays to ListNode)
+
+### Test Setup Patterns
+
+- **Basic**: No setup needed (`""`)
+- **Tree**: `"root = TreeNode.from_list(root_list)\\nexpected = TreeNode.from_list(expected_list)"`
+- **Linked List**: `"head = ListNode.from_list(head_list)\\nexpected = ListNode.from_list(expected_list)"`
+- **Matrix (in-place)**: `"import copy\\noriginal_matrix = copy.deepcopy(matrix)"`
+
+These templates ensure consistency and proper integration with the existing test framework and validation system.

.templates/leetcode/.example/{{cookiecutter.question_name}}/solution.py

@@ -0,0 +1,63 @@
+{
+  // Basic problem template for array/string/number problems
+  // Copy this structure when creating new basic problems
+
+  // REQUIRED: Core identifiers (snake_case for question_name, PascalCase for class_name)
+  "question_name": "two_sum",           // Snake case from problem title
+  "class_name": "TwoSum",               // PascalCase version
+  "method_name": "two_sum",             // Snake case method name
+
+  // REQUIRED: Problem metadata (copy directly from LeetCode)
+  "problem_number": "1",                // String number from URL
+  "problem_title": "Two Sum",           // Exact title from LeetCode
+  "difficulty": "Easy",                 // Easy|Medium|Hard
+  "topics": "Array, Hash Table",        // Comma-separated from LeetCode tags
+
+  // OPTIONAL: Problem categorization tags
+  "tags": ["grind-75"],                 // Popular lists: grind-75, blind-75, neetcode-150, top-interview
+
+  // REQUIRED: Problem description (copy full description from LeetCode)
+  "problem_description": "Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.",
+
+  // REQUIRED: Examples (copy from LeetCode, keep input/output as strings)
+  "examples": [
+    { "input": "nums = [2,7,11,15], target = 9", "output": "[0,1]" },
+    { "input": "nums = [3,2,4], target = 6", "output": "[1,2]" },
+    { "input": "nums = [3,3], target = 6", "output": "[0,1]" }
+  ],
+
+  // REQUIRED: Constraints (copy exactly from LeetCode with \n for line breaks)
+  "constraints": "- 2 <= nums.length <= 10^4\n- -10^9 <= nums[i] <= 10^9\n- -10^9 <= target <= 10^9\n- Only one valid answer exists.",
+
+  // REQUIRED: Method signature components
+  "parameters": "nums: list[int], target: int",    // Modern Python type hints
+  "return_type": "list[int]",                      // Return type with modern syntax
+  "dummy_return": "[]",                            // Default return for TODO implementation
+
+  // REQUIRED: Import statements (empty for basic problems, specify for TreeNode/ListNode)
+  "imports": "",
+
+  // REQUIRED: Test configuration
+  "test_cases": [
+    { "args": [[2, 7, 11, 15], 9], "expected": [0, 1] },
+    { "args": [[3, 2, 4], 6], "expected": [1, 2] },
+    { "args": [[3, 3], 6], "expected": [0, 1] }
+  ],
+
+  // REQUIRED: Test method parameters (use expected, not expected_list for basic problems)
+  "param_names": "nums, target, expected",
+  "param_names_with_types": "nums: list[int], target: int, expected: list[int]",
+
+  // REQUIRED: Test setup and logging
+  "input_description": "nums={nums}, target={target}",
+  "input_params": "nums, target",
+  "expected_param": "expected",
+  "method_args": "nums, target",
+  "test_setup": "",                                // Empty for basic problems
+  "test_logging": "",                              // Empty for default logging
+  "assertion_code": "assert result == expected",
+
+  // REQUIRED: Notebook setup
+  "test_input_setup": "# Example test case\nnums = [2, 7, 11, 15]\ntarget = 9",
+  "expected_output_setup": "expected = [0, 1]"
+}