ci: fix ci

Author: wislertt

.cursor/.dev/update_tags.py

@@ -67,13 +67,14 @@ def update_tags(tag_names=None):
                 # Only include missing problems in the update
                 if missing_problems:
                     update_tags[tag_name] = sorted(missing_problems)
-                    print(
-                        f"{tag_name}: Missing {len(missing_problems)} problems: {sorted(missing_problems)}"
-                    )
+                    missing_list = sorted(missing_problems)
+                    print(f"{tag_name}: Missing {len(missing_problems)} problems: {missing_list}")
 
                 if removed_problems:
+                    removed_list = sorted(removed_problems)
                     print(
-                        f"{tag_name}: Removed {len(removed_problems)} problems: {sorted(removed_problems)} (not included in update)"
+                        f"{tag_name}: Removed {len(removed_problems)} problems: {removed_list} "
+                        f"(not included in update)"
                     )
 
     if not changes_found:

.cursor/commands/problem-creation.md

@@ -301,9 +301,17 @@ The template below uses JSON5 format with comments for documentation purposes on
 - **problem_name**: snake_case (e.g., "two_sum", "valid_palindrome")
 - **solution_class_name**: Usually "Solution", except for design problems (e.g., "LRUCache")
 - **test_class_name**: PascalCase (e.g., "TwoSum", "ValidPalindrome")
-- **method_name**: snake_case (e.g., "two_sum", "is_palindrome")
+- **method_name**: snake_case (e.g., "two_sum", "is_palindrome", "character_replacement")
 - **parameters**: Use snake_case for all parameter names
 
+**CRITICAL: Method Naming Convention**
+
+- Always convert LeetCode method names from camelCase to snake_case
+- Example: `characterReplacement` → `character_replacement`
+- Example: `isSubtree` → `is_subtree`
+- Example: `countSubstrings` → `count_substrings`
+- This ensures Python convention compliance and consistency across the codebase
+
 ### PascalCase Rules for Properties
 
 When creating JSON properties that use PascalCase (solution_class_name, test_class_name):

leetcode/longest_repeating_character_replacement/helpers.py

@@ -1,6 +1,6 @@
 def run_character_replacement(solution_class: type, s: str, k: int):
     implementation = solution_class()
-    return implementation.characterReplacement(s, k)
+    return implementation.character_replacement(s, k)
 
 
 def assert_character_replacement(result: int, expected: int) -> bool:

leetcode/longest_repeating_character_replacement/solution.py

@@ -2,7 +2,7 @@ class Solution:
 
     # Time: O(n) - single pass through string
     # Space: O(1) - at most 26 characters in count dict
-    def characterReplacement(self, s: str, k: int) -> int:
+    def character_replacement(self, s: str, k: int) -> int:
         """
         Find the length of the longest substring with same character
         after at most k replacements using sliding window approach.

leetcode/non_overlapping_intervals/helpers.py

@@ -1,6 +1,6 @@
 def run_erase_overlap_intervals(solution_class: type, intervals: list[list[int]]):
     implementation = solution_class()
-    return implementation.eraseOverlapIntervals(intervals)
+    return implementation.erase_overlap_intervals(intervals)
 
 
 def assert_erase_overlap_intervals(result: int, expected: int) -> bool:

leetcode/non_overlapping_intervals/solution.py

@@ -2,7 +2,7 @@ class Solution:
 
     # Time: O(n log n) - sorting dominates
     # Space: O(1) - no extra space used
-    def eraseOverlapIntervals(self, intervals: list[list[int]]) -> int:
+    def erase_overlap_intervals(self, intervals: list[list[int]]) -> int:
         """
         Find minimum number of intervals to remove to make non-overlapping.
         Uses greedy approach: sort by end time and keep intervals with earliest end times.

leetcode/palindromic_substrings/helpers.py

@@ -1,6 +1,6 @@
 def run_count_substrings(solution_class: type, s: str):
     implementation = solution_class()
-    return implementation.countSubstrings(s)
+    return implementation.count_substrings(s)
 
 
 def assert_count_substrings(result: int, expected: int) -> bool:

leetcode/palindromic_substrings/solution.py

@@ -2,7 +2,7 @@ class Solution:
 
     # Time: O(n^2) - expand around centers approach
     # Space: O(1) - no extra space used
-    def countSubstrings(self, s: str) -> int:
+    def count_substrings(self, s: str) -> int:
         """
         Count palindromic substrings using expand around centers approach.
         For each possible center (single char or between two chars), expand outward

leetcode/subtree_of_another_tree/helpers.py

@@ -5,7 +5,7 @@ def run_is_subtree(solution_class: type, root_list: list[int | None], sub_root_l
     root = TreeNode[int].from_list(root_list)
     sub_root = TreeNode[int].from_list(sub_root_list)
     implementation = solution_class()
-    return implementation.isSubtree(root, sub_root)
+    return implementation.is_subtree(root, sub_root)
 
 
 def assert_is_subtree(result: bool, expected: bool) -> bool:

leetcode/subtree_of_another_tree/solution.py

@@ -5,7 +5,7 @@ class Solution:
 
     # Time: O(m * n) - where m is nodes in root, n is nodes in subRoot
     # Space: O(h) - where h is height of root tree (recursion stack)
-    def isSubtree(self, root: TreeNode[int] | None, subRoot: TreeNode[int] | None) -> bool:
+    def is_subtree(self, root: TreeNode[int] | None, subRoot: TreeNode[int] | None) -> bool:
         """
         Check if subRoot is a subtree of root.
         Uses DFS to check every node in root as potential subtree root.
@@ -20,7 +20,7 @@ def isSubtree(self, root: TreeNode[int] | None, subRoot: TreeNode[int] | None) -
             return True
 
         # Recursively check left and right subtrees
-        return self.isSubtree(root.left, subRoot) or self.isSubtree(root.right, subRoot)
+        return self.is_subtree(root.left, subRoot) or self.is_subtree(root.right, subRoot)
 
     def _is_same_tree(self, p: TreeNode[int] | None, q: TreeNode[int] | None) -> bool:
         """Helper method to check if two trees are identical."""