feat: add Valid Parentheses

Author: wislertt

.templates/leetcode/json/valid_parentheses.json

@@ -0,0 +1,41 @@
+{
+    "problem_name": "valid_parentheses",
+    "solution_class_name": "Solution",
+    "problem_number": "20",
+    "problem_title": "Valid Parentheses",
+    "difficulty": "Easy",
+    "topics": "String, Stack",
+    "tags": ["grind-75"],
+    "readme_description": "Given a string `s` containing just the characters `'('`, `')'`, `'{'`, `'}'`, `'['` and `']'`, determine if the input string is valid.\n\nAn input string is valid if:\n\n1. Open brackets must be closed by the same type of brackets.\n2. Open brackets must be closed in the correct order.\n3. Every close bracket has a corresponding open bracket of the same type.",
+    "readme_examples": [
+        { "content": "```\nInput: s = \"()\"\nOutput: true\n```" },
+        { "content": "```\nInput: s = \"()[]{}\"\nOutput: true\n```" },
+        { "content": "```\nInput: s = \"(]\"\nOutput: false\n```" },
+        { "content": "```\nInput: s = \"([])\"\nOutput: true\n```" },
+        { "content": "```\nInput: s = \"([)]\"\nOutput: false\n```" }
+    ],
+    "readme_constraints": "- `1 <= s.length <= 10^4`\n- `s` consists of parentheses only `'()[]{}'`.",
+    "readme_additional": "",
+    "solution_imports": "",
+    "solution_methods": [
+        { "name": "is_valid", "parameters": "s: str", "return_type": "bool", "dummy_return": "False" }
+    ],
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .solution import Solution",
+    "test_class_name": "ValidParentheses",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_is_valid",
+            "parametrize": "s, expected",
+            "parametrize_typed": "s: str, expected: bool",
+            "test_cases": "[('()', True), ('()[]{}', True), ('(]', False), ('([])', True), ('([)]', False), ('', True), ('(', False), (')', False), ('{[()]}', True), ('{[(])}', False)]",
+            "body": "result = self.solution.is_valid(s)\nassert result == expected"
+        }
+    ],
+    "playground_imports": "from solution import Solution",
+    "playground_test_case": "# Example test case\ns = '()'\nexpected = True",
+    "playground_execution": "result = Solution().is_valid(s)\nresult",
+    "playground_assertion": "assert result == expected"
+}

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= flood_fill
+PROBLEM ?= valid_parentheses
 FORCE ?= 0
 COMMA := ,
 

leetcode/valid_parentheses/README.md

@@ -0,0 +1,59 @@
+# Valid Parentheses
+
+**Difficulty:** Easy
+**Topics:** String, Stack
+**Tags:** grind-75
+
+**LeetCode:** [Problem 20](https://leetcode.com/problems/valid-parentheses/description/)
+
+## Problem Description
+
+Given a string `s` containing just the characters `'('`, `')'`, `'{'`, `'}'`, `'['` and `']'`, determine if the input string is valid.
+
+An input string is valid if:
+
+1. Open brackets must be closed by the same type of brackets.
+2. Open brackets must be closed in the correct order.
+3. Every close bracket has a corresponding open bracket of the same type.
+
+## Examples
+
+### Example 1:
+
+```
+Input: s = "()"
+Output: true
+```
+
+### Example 2:
+
+```
+Input: s = "()[]{}"
+Output: true
+```
+
+### Example 3:
+
+```
+Input: s = "(]"
+Output: false
+```
+
+### Example 4:
+
+```
+Input: s = "([])"
+Output: true
+```
+
+### Example 5:
+
+```
+Input: s = "([)]"
+Output: false
+```
+
+## Constraints
+
+- `1 <= s.length <= 10^4`
+- `s` consists of parentheses only `'()[]{}'`.

leetcode/valid_parentheses/__init__.py

@@ -0,0 +1,67 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "imports",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from solution import Solution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "setup",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example test case\n",
+    "s = \"()\"\n",
+    "expected = True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "result = Solution().is_valid(s)\nresult"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "test",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert result == expected"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "leetcode-py-py3.13",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python3",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

leetcode/valid_parentheses/playground.ipynb

@@ -0,0 +1,14 @@
+class Solution:
+    # Time: O(n)
+    # Space: O(n)
+    def is_valid(self, s: str) -> bool:
+        stack = []
+        pairs = {"(": ")", "[": "]", "{": "}"}
+
+        for char in s:
+            if char in pairs:
+                stack.append(char)
+            elif not stack or pairs[stack.pop()] != char:
+                return False
+
+        return not stack

leetcode/valid_parentheses/solution.py

@@ -0,0 +1,46 @@
+import pytest
+
+from leetcode_py.test_utils import logged_test
+
+from .solution import Solution
+
+
+class TestValidParentheses:
+    def setup_method(self):
+        self.solution = Solution()
+
+    @pytest.mark.parametrize(
+        "s, expected",
+        [
+            ("()", True),
+            ("()[]{}", True),
+            ("(]", False),
+            ("([])", True),
+            ("([)]", False),
+            ("", True),
+            ("(", False),
+            (")", False),
+            ("{[()]}", True),
+            ("{[(])}", False),
+            ("(((", False),
+            (")))", False),
+            ("()()()", True),
+            ("({[]})", True),
+            ("({[}])", False),
+            ("[[[[[]]]]]", True),
+            ("[[[[[]]]]", False),
+            ("{{{{{}}}}}", True),
+            ("((((((((((", False),
+            ("))))))))))", False),
+            ("(){}[]", True),
+            ("([{}])", True),
+            ("([{]})", False),
+            ("(())", True),
+            ("(()", False),
+            ("())", False),
+        ],
+    )
+    @logged_test
+    def test_is_valid(self, s: str, expected: bool):
+        result = self.solution.is_valid(s)
+        assert result == expected