leetcode-py-sdk 0.47.0__tar.gz → 1.0.0__tar.gz

{leetcode_py_sdk-0.47.0 → leetcode_py_sdk-1.0.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.3
 Name: leetcode-py-sdk
-Version: 0.47.0
+Version: 1.0.0
 Summary: Modern Python LeetCode practice environment with automated problem generation, beautiful data structure visualizations, and comprehensive testing
 Keywords: algorithms,coding-practice,data-structures,interview-prep,leetcode
 Author: Wisaroot Lertthaweedech
 Author-email: Wisaroot Lertthaweedech <l.wisaroot@gmail.com>
 License: Apache-2.0
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
 Classifier: License :: OSI Approved :: Apache Software License
@@ -77,14 +77,13 @@ A Python package to generate professional LeetCode practice environments. Featur
 **Current Problem Sets**:
 
 - **grind-75** - Essential coding interview questions from [Grind 75](https://www.techinterviewhandbook.org/grind75/) ✅ Complete
-- **grind** - Extended Grind collection including all Grind 75 plus additional problems 🚧 Partial
+- **grind** - Extended Grind collection including all Grind 75 plus additional problems ✅ Complete
 - **blind-75** - Original [Blind 75](https://leetcode.com/problem-list/xi4ci4ig/) curated list ✅ Complete
 - **neetcode-150** - Comprehensive [NeetCode 150](https://neetcode.io/practice) problem set ✅ Complete
+- **neetcode-250** - Full [NeetCode 250](https://neetcode.io/practice) roadmap extending NeetCode 150 with 100 more problems ✅ Complete
 - **algo-master-75** - Curated algorithmic mastery problems ✅ Complete
 
-**Coverage**: 130+ unique problems across all major coding interview topics and difficulty levels.
-
-**Note**: Some problem sets are partially covered. We're actively working to complete all collections. [Contributions welcome!](https://github.com/wislertt/leetcode-py/blob/main/CONTRIBUTING.md)
+**Coverage**: 300+ unique problems across all major coding interview topics and difficulty levels. All problem sets are complete. [Contributions welcome!](https://github.com/wislertt/leetcode-py/blob/main/CONTRIBUTING.md)
 
 ## <a id="quick-start"></a>🚀 Quick Start
 
@@ -100,7 +99,7 @@ pip install leetcode-py-sdk
 # Generate problems anywhere
 lcpy gen -n 1                    # Generate Two Sum
 lcpy gen -t grind-75             # Generate all Grind 75 problems
-lcpy gen -t neetcode-150         # Generate NeetCode 150 problems
+lcpy gen -t neetcode-250         # Generate NeetCode 250 problems
 lcpy list -t grind-75            # List Grind 75 problems
 lcpy list -t blind-75            # List Blind 75 problems
 
@@ -114,7 +113,7 @@ python -m pytest test_solution.py  # Run tests
 
 ```bash
 lcpy gen --problem-tag grind-75 --output leetcode     # Generate all Grind 75 problems
-lcpy gen --problem-tag neetcode-150 --output leetcode   # Generate NeetCode 150 problems
+lcpy gen --problem-tag neetcode-250 --output leetcode   # Generate NeetCode 250 problems
 lcpy gen --problem-tag blind-75 --output leetcode       # Generate Blind 75 problems
 ```
 
@@ -304,7 +303,7 @@ uv run python -m leetcode_py.tools.check_test_cases --threshold=10
 lcpy gen -n 1                       # Single problem by number
 lcpy gen -s two-sum                 # Single problem by slug
 lcpy gen -t grind-75                # Bulk generation by tag
-lcpy gen -t neetcode-150            # Generate NeetCode 150 problems
+lcpy gen -t neetcode-250            # Generate NeetCode 250 problems
 lcpy gen -n 1 -n 2 -n 3            # Multiple problems
 lcpy gen -t grind-75 -d Easy       # Filter by difficulty
 lcpy gen -n 1 -o my-problems       # Custom output directory
@@ -313,7 +312,7 @@ lcpy gen -n 1 -o my-problems       # Custom output directory
 lcpy list                           # All available problems
 lcpy list -t grind-75               # Filter by Grind 75 tag
 lcpy list -t blind-75               # Filter by Blind 75 tag
-lcpy list -t neetcode-150           # Filter by NeetCode 150 tag
+lcpy list -t neetcode-250           # Filter by NeetCode 250 tag
 lcpy list -d Medium                 # Filter by difficulty
 
 # Scrape problem data

{leetcode_py_sdk-0.47.0 → leetcode_py_sdk-1.0.0}/README.md

@@ -41,14 +41,13 @@ A Python package to generate professional LeetCode practice environments. Featur
 **Current Problem Sets**:
 
 - **grind-75** - Essential coding interview questions from [Grind 75](https://www.techinterviewhandbook.org/grind75/) ✅ Complete
-- **grind** - Extended Grind collection including all Grind 75 plus additional problems 🚧 Partial
+- **grind** - Extended Grind collection including all Grind 75 plus additional problems ✅ Complete
 - **blind-75** - Original [Blind 75](https://leetcode.com/problem-list/xi4ci4ig/) curated list ✅ Complete
 - **neetcode-150** - Comprehensive [NeetCode 150](https://neetcode.io/practice) problem set ✅ Complete
+- **neetcode-250** - Full [NeetCode 250](https://neetcode.io/practice) roadmap extending NeetCode 150 with 100 more problems ✅ Complete
 - **algo-master-75** - Curated algorithmic mastery problems ✅ Complete
 
-**Coverage**: 130+ unique problems across all major coding interview topics and difficulty levels.
-
-**Note**: Some problem sets are partially covered. We're actively working to complete all collections. [Contributions welcome!](https://github.com/wislertt/leetcode-py/blob/main/CONTRIBUTING.md)
+**Coverage**: 300+ unique problems across all major coding interview topics and difficulty levels. All problem sets are complete. [Contributions welcome!](https://github.com/wislertt/leetcode-py/blob/main/CONTRIBUTING.md)
 
 ## <a id="quick-start"></a>🚀 Quick Start
 
@@ -64,7 +63,7 @@ pip install leetcode-py-sdk
 # Generate problems anywhere
 lcpy gen -n 1                    # Generate Two Sum
 lcpy gen -t grind-75             # Generate all Grind 75 problems
-lcpy gen -t neetcode-150         # Generate NeetCode 150 problems
+lcpy gen -t neetcode-250         # Generate NeetCode 250 problems
 lcpy list -t grind-75            # List Grind 75 problems
 lcpy list -t blind-75            # List Blind 75 problems
 
@@ -78,7 +77,7 @@ python -m pytest test_solution.py  # Run tests
 
 ```bash
 lcpy gen --problem-tag grind-75 --output leetcode     # Generate all Grind 75 problems
-lcpy gen --problem-tag neetcode-150 --output leetcode   # Generate NeetCode 150 problems
+lcpy gen --problem-tag neetcode-250 --output leetcode   # Generate NeetCode 250 problems
 lcpy gen --problem-tag blind-75 --output leetcode       # Generate Blind 75 problems
 ```
 
@@ -268,7 +267,7 @@ uv run python -m leetcode_py.tools.check_test_cases --threshold=10
 lcpy gen -n 1                       # Single problem by number
 lcpy gen -s two-sum                 # Single problem by slug
 lcpy gen -t grind-75                # Bulk generation by tag
-lcpy gen -t neetcode-150            # Generate NeetCode 150 problems
+lcpy gen -t neetcode-250            # Generate NeetCode 250 problems
 lcpy gen -n 1 -n 2 -n 3            # Multiple problems
 lcpy gen -t grind-75 -d Easy       # Filter by difficulty
 lcpy gen -n 1 -o my-problems       # Custom output directory
@@ -277,7 +276,7 @@ lcpy gen -n 1 -o my-problems       # Custom output directory
 lcpy list                           # All available problems
 lcpy list -t grind-75               # Filter by Grind 75 tag
 lcpy list -t blind-75               # Filter by Blind 75 tag
-lcpy list -t neetcode-150           # Filter by NeetCode 150 tag
+lcpy list -t neetcode-250           # Filter by NeetCode 250 tag
 lcpy list -d Medium                 # Filter by difficulty
 
 # Scrape problem data

{leetcode_py_sdk-0.47.0 → leetcode_py_sdk-1.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "leetcode-py-sdk"
-version = "0.47.0" # use git tag instead
+version = "1.0.0" # use git tag instead
 description = "Modern Python LeetCode practice environment with automated problem generation, beautiful data structure visualizations, and comprehensive testing"
 authors = [
   {name = "Wisaroot Lertthaweedech", email = "l.wisaroot@gmail.com"}
@@ -10,7 +10,7 @@ readme = "README.md"
 requires-python = ">=3.10"
 keywords = ["algorithms", "coding-practice", "data-structures", "interview-prep", "leetcode"]
 classifiers = [
-  "Development Status :: 4 - Beta",
+  "Development Status :: 5 - Production/Stable",
   "Intended Audience :: Developers",
   "Intended Audience :: Education",
   "License :: OSI Approved :: Apache Software License",

leetcode_py_sdk-1.0.0/src/leetcode_py/cli/resources/leetcode/json/problems/all_nodes_distance_k_in_binary_tree.json

@@ -0,0 +1,82 @@
+{
+    "problem_name": "all_nodes_distance_k_in_binary_tree",
+    "solution_class_name": "Solution",
+    "problem_number": "863",
+    "problem_title": "All Nodes Distance K in Binary Tree",
+    "difficulty": "Medium",
+    "topics": "Hash Table, Tree, Depth-First Search, Breadth-First Search, Binary Tree",
+    "_tags": { "list": ["grind"] },
+    "readme_description": "Given the `root` of a binary tree, the value of a target node `target`, and an integer `k`, return an array of the values of all nodes that have a distance `k` from the target node.\n\nThe value of `target` is given as an integer (all node values are unique). You can return the answer in any order.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "![Example 1](https://s3-lc-upload.s3.amazonaws.com/uploads/2018/06/28/sketch0.png)\n\n```\nInput: root = [3,5,1,6,2,0,8,null,null,7,4], target = 5, k = 2\nOutput: [7,4,1]\nExplanation: The nodes that are a distance 2 from the target node (with value 5) have values 7, 4, and 1.\n```"
+            },
+            {
+                "content": "```\nInput: root = [1], target = 1, k = 3\nOutput: []\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- The number of nodes in the tree is in the range [1, 500].\n- 0 <= Node.val <= 500\n- All the values `Node.val` are **unique**.\n- `target` is the value of one of the nodes in the tree.\n- 0 <= k <= 1000",
+    "readme_additional": "",
+    "helpers_imports": "from leetcode_py import TreeNode",
+    "helpers_content": "",
+    "helpers_run_name": "distance_k",
+    "helpers_run_signature": "(solution_class: type, root_list: list[int | None], target: int, k: int)",
+    "helpers_run_body": "    root = TreeNode[int].from_list(root_list)\n    implementation = solution_class()\n    return implementation.distance_k(root, target, k)",
+    "helpers_assert_name": "distance_k",
+    "helpers_assert_signature": "(result: list[int], expected: list[int]) -> bool",
+    "helpers_assert_body": "    # Order does not matter; sort both sides for comparison\n    assert sorted(result) == sorted(expected)\n    return True",
+    "solution_imports": "from collections import deque\n\nfrom leetcode_py import TreeNode",
+    "solution_contents": "",
+    "solution_class_content": "",
+    "test_imports": "import pytest\nfrom leetcode_py import logged_test\nfrom .helpers import assert_distance_k, run_distance_k\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "AllNodesDistanceKInBinaryTree",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "distance_k",
+                "signature": "(self, root: TreeNode[int] | None, target: int, k: int) -> list[int]",
+                "body": "        # TODO: Implement distance_k\n        return []"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_distance_k",
+                "signature": "(self, root_list: list[int | None], target: int, k: int, expected: list[int])",
+                "parametrize": "root_list, target, k, expected",
+                "test_cases": {
+                    "list": [
+                        "([3, 5, 1, 6, 2, 0, 8, None, None, 7, 4], 5, 2, [7, 4, 1])",
+                        "([1], 1, 3, [])",
+                        "([1], 1, 0, [1])",
+                        "([3, 5, 1, 6, 2, 0, 8, None, None, 7, 4], 5, 0, [5])",
+                        "([3, 5, 1, 6, 2, 0, 8, None, None, 7, 4], 3, 1, [5, 1])",
+                        "([3, 5, 1, 6, 2, 0, 8, None, None, 7, 4], 3, 2, [6, 2, 0, 8])",
+                        "([1, 2, 3, 4, 5], 2, 2, [3])",
+                        "([1, 2, 3, 4, 5], 4, 1, [2])",
+                        "([1, 2, 3, 4, 5], 4, 2, [1, 5])",
+                        "([1, 2], 1, 1, [2])",
+                        "([1, 2], 2, 1, [1])",
+                        "([1, 2, 3], 2, 2, [3])",
+                        "([1, None, 2, None, 3], 1, 1, [2])",
+                        "([3, 5, 1, 6, 2, 0, 8, None, None, 7, 4], 7, 3, [3, 6])",
+                        "([1, 2, 3, 4, 5, 6, 7], 3, 3, [4, 5])"
+                    ]
+                },
+                "body": "        result = run_distance_k(Solution, root_list, target, k)\n        assert_distance_k(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_distance_k, assert_distance_k\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nroot_list: list[int | None] = [3, 5, 1, 6, 2, 0, 8, None, None, 7, 4]\ntarget = 5\nk = 2\nexpected = [7, 4, 1]",
+    "playground_run": "result = run_distance_k(Solution, root_list, target, k)\nresult",
+    "playground_assert": "assert_distance_k(result, expected)"
+}

leetcode_py_sdk-1.0.0/src/leetcode_py/cli/resources/leetcode/json/problems/asteroid_collision.json

@@ -0,0 +1,88 @@
+{
+    "problem_name": "asteroid_collision",
+    "solution_class_name": "Solution",
+    "problem_number": "735",
+    "problem_title": "Asteroid Collision",
+    "difficulty": "Medium",
+    "topics": "Array, Stack, Simulation",
+    "_tags": { "list": ["grind"] },
+    "readme_description": "We are given an array `asteroids` of integers representing asteroids in a row. The indices of the asteroid in the array represent their relative position in space.\n\nFor each asteroid, the absolute value represents its size, and the sign represents its direction (positive meaning right, negative meaning left). Each asteroid moves at the same speed.\n\nFind out the state of the asteroids after all collisions. If two asteroids meet, the smaller one will explode. If both are the same size, both will explode. Two asteroids moving in the same direction, or two moving away from each other, will never meet.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: asteroids = [5,10,-5]\nOutput: [5,10]\nExplanation: The 10 and -5 collide resulting in 10. The 5 and 10 never collide.\n```"
+            },
+            {
+                "content": "```\nInput: asteroids = [8,-8]\nOutput: []\nExplanation: The 8 and -8 collide exploding each other.\n```"
+            },
+            {
+                "content": "```\nInput: asteroids = [10,2,-5]\nOutput: [10]\nExplanation: The 2 and -5 collide resulting in -5. The 10 and -5 collide resulting in 10.\n```"
+            },
+            {
+                "content": "```\nInput: asteroids = [3,5,-6,2,-1,4]\nOutput: [-6,2,4]\nExplanation: The asteroid -6 makes the asteroid 3 and 5 explode, and then continues going left. On the other side, the asteroid 2 destroys -1. Since 2 and 4 are both moving right, they never collide.\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- 2 <= asteroids.length <= 10^4\n- -1000 <= asteroids[i] <= 1000\n- `asteroids[i] != 0`",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "asteroid_collision",
+    "helpers_run_signature": "(solution_class: type, asteroids: list[int])",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.asteroid_collision(asteroids)",
+    "helpers_assert_name": "asteroid_collision",
+    "helpers_assert_signature": "(result: list[int], expected: list[int]) -> bool",
+    "helpers_assert_body": "    assert result == expected\n    return True",
+    "solution_imports": "",
+    "solution_contents": "",
+    "solution_class_content": "",
+    "test_imports": "import pytest\nfrom leetcode_py import logged_test\nfrom .helpers import assert_asteroid_collision, run_asteroid_collision\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "AsteroidCollision",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "asteroid_collision",
+                "signature": "(self, asteroids: list[int]) -> list[int]",
+                "body": "        # TODO: Implement asteroid_collision\n        return []"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_asteroid_collision",
+                "signature": "(self, asteroids: list[int], expected: list[int])",
+                "parametrize": "asteroids, expected",
+                "test_cases": {
+                    "list": [
+                        "([5, 10, -5], [5, 10])",
+                        "([8, -8], [])",
+                        "([10, 2, -5], [10])",
+                        "([3, 5, -6, 2, -1, 4], [-6, 2, 4])",
+                        "([-2, -1, 1, 2], [-2, -1, 1, 2])",
+                        "([1, 2, 3, 4], [1, 2, 3, 4])",
+                        "([-1, -2, -3], [-1, -2, -3])",
+                        "([5, 5, -5], [5])",
+                        "([5, 10, -5, -10], [5])",
+                        "([10, 5, -5], [10])",
+                        "([-2, 2, -1, -2], [-2])",
+                        "([1, -2, -3], [-2, -3])",
+                        "([2, -1, -2], [])",
+                        "([5, -5], [])",
+                        "([-1, 5, -5, 1], [-1, 1])"
+                    ]
+                },
+                "body": "        result = run_asteroid_collision(Solution, asteroids)\n        assert_asteroid_collision(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_asteroid_collision, assert_asteroid_collision\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nasteroids = [5, 10, -5]\nexpected = [5, 10]",
+    "playground_run": "result = run_asteroid_collision(Solution, asteroids)\nresult",
+    "playground_assert": "assert_asteroid_collision(result, expected)"
+}

leetcode_py_sdk-1.0.0/src/leetcode_py/cli/resources/leetcode/json/problems/backspace_string_compare.json

@@ -0,0 +1,85 @@
+{
+    "problem_name": "backspace_string_compare",
+    "solution_class_name": "Solution",
+    "problem_number": "844",
+    "problem_title": "Backspace String Compare",
+    "difficulty": "Easy",
+    "topics": "Two Pointers, String, Stack, Simulation",
+    "_tags": { "list": ["grind"] },
+    "readme_description": "Given two strings `s` and `t`, return `true` if they are equal when both are typed into empty text editors. `'#'` means a backspace character.\n\nNote that after backspacing an empty text, the text will continue empty.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: s = \"ab#c\", t = \"ad#c\"\nOutput: true\nExplanation: Both s and t become \"ac\".\n```"
+            },
+            {
+                "content": "```\nInput: s = \"ab##\", t = \"c#d#\"\nOutput: true\nExplanation: Both s and t become \"\".\n```"
+            },
+            {
+                "content": "```\nInput: s = \"a#c\", t = \"b\"\nOutput: false\nExplanation: s becomes \"c\" while t becomes \"b\".\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- 1 <= s.length, t.length <= 200\n- `s` and `t` only contain lowercase letters and `'#'` characters.",
+    "readme_additional": "**Follow up:** Can you solve it in `O(n)` time and `O(1)` space?",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "backspace_compare",
+    "helpers_run_signature": "(solution_class: type, s: str, t: str)",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.backspace_compare(s, t)",
+    "helpers_assert_name": "backspace_compare",
+    "helpers_assert_signature": "(result: bool, expected: bool) -> bool",
+    "helpers_assert_body": "    assert result == expected\n    return True",
+    "solution_imports": "",
+    "solution_contents": "",
+    "solution_class_content": "",
+    "test_imports": "import pytest\nfrom leetcode_py import logged_test\nfrom .helpers import assert_backspace_compare, run_backspace_compare\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "BackspaceStringCompare",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "backspace_compare",
+                "signature": "(self, s: str, t: str) -> bool",
+                "body": "        # TODO: Implement backspace_compare\n        return False"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_backspace_compare",
+                "signature": "(self, s: str, t: str, expected: bool)",
+                "parametrize": "s, t, expected",
+                "test_cases": {
+                    "list": [
+                        "('ab#c', 'ad#c', True)",
+                        "('ab##', 'c#d#', True)",
+                        "('a#c', 'b', False)",
+                        "('a', 'a', True)",
+                        "('#', '#', True)",
+                        "('a#', '', True)",
+                        "('a#b', 'b', True)",
+                        "('###', '', True)",
+                        "('a##c', '#a#c', True)",
+                        "('xywrrmp', 'xywrrmu#p', True)",
+                        "('c##vnvr', 'vnvr', True)",
+                        "('nzp#o', 'b#nzp#o', True)",
+                        "('abc', 'abc', True)",
+                        "('a', 'b', False)",
+                        "('ab#c', 'ad#d', False)"
+                    ]
+                },
+                "body": "        result = run_backspace_compare(Solution, s, t)\n        assert_backspace_compare(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_backspace_compare, assert_backspace_compare\nfrom solution import Solution",
+    "playground_setup": "# Example test case\ns = 'ab#c'\nt = 'ad#c'\nexpected = True",
+    "playground_run": "result = run_backspace_compare(Solution, s, t)\nresult",
+    "playground_assert": "assert_backspace_compare(result, expected)"
+}

leetcode_py_sdk-1.0.0/src/leetcode_py/cli/resources/leetcode/json/problems/baseball_game.json

@@ -0,0 +1,82 @@
+{
+    "problem_name": "baseball_game",
+    "solution_class_name": "Solution",
+    "problem_number": "682",
+    "problem_title": "Baseball Game",
+    "difficulty": "Easy",
+    "topics": "Array, Stack, Simulation",
+    "_tags": { "list": ["neetcode-250"] },
+    "readme_description": "You are keeping the scores for a baseball game with strange rules. At the beginning of the game, you start with an empty record.\n\nYou are given a list of strings `operations`, where `operations[i]` is the `ith` operation you must apply to the record and is one of the following:\n\n- An integer `x`.\n  - Record a new score of `x`.\n- `'+'`.\n  - Record a new score that is the sum of the previous two scores.\n- `'D'`.\n  - Record a new score that is the double of the previous score.\n- `'C'`.\n  - Invalidate the previous score, removing it from the record.\n\nReturn the sum of all the scores on the record after applying all the operations.\n\nThe test cases are generated such that the answer and all intermediate calculations fit in a **32-bit** integer and that all operations are valid.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: ops = [\"5\",\"2\",\"C\",\"D\",\"+\"]\nOutput: 30\nExplanation:\n\"5\" - Add 5 to the record, record is now [5].\n\"2\" - Add 2 to the record, record is now [5, 2].\n\"C\" - Invalidate and remove the previous score, record is now [5].\n\"D\" - Add 2 * 5 = 10 to the record, record is now [5, 10].\n\"+\" - Add 5 + 10 = 15 to the record, record is now [5, 10, 15].\nThe total sum is 5 + 10 + 15 = 30.\n```"
+            },
+            {
+                "content": "```\nInput: ops = [\"5\",\"-2\",\"4\",\"C\",\"D\",\"9\",\"+\",\"+\"]\nOutput: 27\n```"
+            },
+            { "content": "```\nInput: ops = [\"1\",\"C\"]\nOutput: 0\n```" }
+        ]
+    },
+    "readme_constraints": "- 1 <= operations.length <= 1000\n- `operations[i]` is `\"C\"`, `\"D\"`, `\"+\"`, or a string representing an integer in the range [-3 * 10^4, 3 * 10^4].\n- For operation `\"+\"`, there will always be at least two previous scores on the record.\n- For operations `\"C\"` and `\"D\"`, there will always be at least one previous score on the record.",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "cal_points",
+    "helpers_run_signature": "(solution_class: type, operations: list[str])",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.cal_points(operations)",
+    "helpers_assert_name": "cal_points",
+    "helpers_assert_signature": "(result: int, expected: int) -> bool",
+    "helpers_assert_body": "    assert result == expected\n    return True",
+    "solution_imports": "",
+    "solution_contents": "",
+    "solution_class_content": "",
+    "test_imports": "import pytest\nfrom leetcode_py import logged_test\nfrom .helpers import assert_cal_points, run_cal_points\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "BaseballGame",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "cal_points",
+                "signature": "(self, operations: list[str]) -> int",
+                "body": "        # TODO: Implement cal_points\n        return 0"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_cal_points",
+                "signature": "(self, operations: list[str], expected: int)",
+                "parametrize": "operations, expected",
+                "test_cases": {
+                    "list": [
+                        "(['5', '2', 'C', 'D', '+'], 30)",
+                        "(['5', '-2', '4', 'C', 'D', '9', '+', '+'], 27)",
+                        "(['1', 'C'], 0)",
+                        "(['5'], 5)",
+                        "(['1', '2', '3'], 6)",
+                        "(['1', '2', '+', '+'], 11)",
+                        "(['1', 'D', 'D'], 7)",
+                        "(['-1', 'D', '+'], -6)",
+                        "(['10', '20', 'C', 'C', '5'], 5)",
+                        "(['1', '2', '3', 'C', 'C', 'C'], 0)",
+                        "(['100', 'D', '+', 'C'], 300)",
+                        "(['0', '0', '0', '+'], 0)",
+                        "(['-5', 'D'], -15)",
+                        "(['1', '2', 'D', '+', 'C'], 7)"
+                    ]
+                },
+                "body": "        result = run_cal_points(Solution, operations)\n        assert_cal_points(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_cal_points, assert_cal_points\nfrom solution import Solution",
+    "playground_setup": "# Example test case\noperations = ['5', '2', 'C', 'D', '+']\nexpected = 30",
+    "playground_run": "result = run_cal_points(Solution, operations)\nresult",
+    "playground_assert": "assert_cal_points(result, expected)"
+}

leetcode_py_sdk-1.0.0/src/leetcode_py/cli/resources/leetcode/json/problems/basic_calculator_ii.json

@@ -0,0 +1,94 @@
+{
+    "problem_name": "basic_calculator_ii",
+    "solution_class_name": "Solution",
+    "problem_number": "227",
+    "problem_title": "Basic Calculator II",
+    "difficulty": "Medium",
+    "topics": "Math, String, Stack",
+    "_tags": {
+        "list": ["grind"]
+    },
+    "readme_description": "Given a string `s` which represents an expression, evaluate this expression and return its value.\n\nThe integer division should truncate toward zero.\n\nYou may assume that the given expression is always valid. All intermediate results will be in the range of [-2^31, 2^31 - 1].\n\n**Note:** You are not allowed to use any built-in function which evaluates strings as mathematical expressions, such as `eval()`.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: s = \"3+2*2\"\nOutput: 7\n```"
+            },
+            {
+                "content": "```\nInput: s = \" 3/2 \"\nOutput: 1\n```"
+            },
+            {
+                "content": "```\nInput: s = \" 3+5 / 2 \"\nOutput: 5\n```"
+            }
+        ]
+    },
+    "readme_constraints": "- 1 <= s.length <= 3 * 10^5\n- s consists of integers and operators ('+', '-', '*', '/') separated by some number of spaces.\n- s represents a valid expression.\n- All the integers in the expression are non-negative integers in the range [0, 2^31 - 1].\n- The answer is guaranteed to fit in a 32-bit integer.",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "calculate",
+    "helpers_run_signature": "(solution_class: type, s: str)",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.calculate(s)",
+    "helpers_assert_name": "calculate",
+    "helpers_assert_signature": "(result: int, expected: int) -> bool",
+    "helpers_assert_body": "    assert result == expected\n    return True",
+    "solution_imports": "",
+    "solution_contents": "",
+    "solution_class_content": "",
+    "test_imports": "import pytest\nfrom leetcode_py import logged_test\nfrom .helpers import assert_calculate, run_calculate\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "BasicCalculatorII",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "calculate",
+                "signature": "(self, s: str) -> int",
+                "body": "        # TODO: Implement calculate\n        return 0"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [
+            {
+                "name": "setup_method",
+                "parameters": "",
+                "body": "self.solution = Solution()"
+            }
+        ]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_calculate",
+                "signature": "(self, s: str, expected: int)",
+                "parametrize": "s, expected",
+                "test_cases": {
+                    "list": [
+                        "('3+2*2', 7)",
+                        "(' 3/2 ', 1)",
+                        "(' 3+5 / 2 ', 5)",
+                        "('1+1', 2)",
+                        "('1-1', 0)",
+                        "('2*3+4', 10)",
+                        "('10/2', 5)",
+                        "('14-3/2', 13)",
+                        "('0', 0)",
+                        "('100000000/1/1', 100000000)",
+                        "('1*2*3*4*5', 120)",
+                        "('3+2*2*2', 11)",
+                        "(' 5 ', 5)",
+                        "('1-1+1', 1)",
+                        "('2/3', 0)",
+                        "('100-10-10', 80)"
+                    ]
+                },
+                "body": "        result = run_calculate(Solution, s)\n        assert_calculate(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_calculate, assert_calculate\nfrom solution import Solution",
+    "playground_setup": "# Example test case\ns = '3+2*2'\nexpected = 7",
+    "playground_run": "result = run_calculate(Solution, s)\nresult",
+    "playground_assert": "assert_calculate(result, expected)"
+}