Merge branch 'main' into feat/cli

Author: scarowar

problems/0020-valid-parentheses/README.md

@@ -0,0 +1,20 @@
+# Problem 0020: Valid Parentheses
+
+## Link
+https://leetcode.com/problems/valid-parentheses/
+
+## Intuition
+Use a stack to ensure every opening bracket has a matching closing bracket in the correct order.
+
+## Approach
+Iterate through the string, pushing opening brackets onto a stack and popping to match each closing bracket; return false if a mismatch or leftover remains.
+
+## Complexity
+- Time: O(n)
+- Space: O(n)
+
+## Notes
+- Handle cases where the string starts with a closing bracket or ends with unmatched openings.
+- Use a helper function to map each closing bracket to its corresponding opening bracket.
+- Works for all three bracket types: (), {}, [].
+- Returns false immediately on any mismatch or if the stack is not empty at the end.

problems/0020-valid-parentheses/solution.py

@@ -0,0 +1,37 @@
+from collections import deque
+
+
+class Solution:
+    def isValid(self, s: str) -> bool:
+        result = deque()
+
+        for c in s:
+            if c in "({[":
+                result.append(c)
+            else:
+                if result:
+                    left = result.pop()
+                    if left != self.getLeft(c):
+                        return False
+                else:
+                    return False
+
+        return not result
+
+    def getLeft(self, c):
+        if c == ")":
+            return "("
+        elif c == "}":
+            return "{"
+        return "["
+
+
+if __name__ == "__main__":
+    s = Solution()
+    print(s.isValid("()"))  # Expected: True
+    print(s.isValid("()[]{}"))  # Expected: True
+    print(s.isValid("(]"))  # Expected: False
+    print(s.isValid("([])"))  # Expected: True
+    print(s.isValid("(()"))  # Expected: False
+    print(s.isValid("("))  # Expected: False
+    print(s.isValid("]"))  # Expected: False

problems/0206-reverse-linked-list/README.md

@@ -0,0 +1,22 @@
+# Problem 0206: Reverse Linked List
+
+## Link
+https://leetcode.com/problems/reverse-linked-list/
+
+## Intuition
+Reversing a linked list means making each node point to its previous node instead of the next.
+
+## Approach
+Use three pointers—previous, current, and next—to iteratively reverse the direction of each node’s pointer until the end of the list.
+
+## Complexity
+- Time: O(n)
+- Space: O(1)
+
+## Notes
+- Handles empty and single-node lists without extra checks.
+- Always update all pointers in each loop to avoid losing access to the rest of the list.
+- The final head is the last non-null node processed.
+- Common mistake: forgetting to update the next pointer before reversing the link.
+
+NeetCode 150: true

problems/0206-reverse-linked-list/solution.py

@@ -0,0 +1,46 @@
+from typing import *
+
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        if not head or not head.next:
+            return head
+        
+        pre, cur, nxt = None, head, head.next
+        while cur:
+            cur.next = pre
+
+            pre = cur
+            cur = nxt
+            if nxt:
+                nxt = nxt.next
+        
+        return pre
+
+if __name__ == "__main__":
+    def list_to_linkedlist(lst):
+        dummy = ListNode()
+        curr = dummy
+        for val in lst:
+            curr.next = ListNode(val)
+            curr = curr.next
+        return dummy.next
+
+    def linkedlist_to_list(node):
+        result = []
+        while node:
+            result.append(node.val)
+            node = node.next
+        return result
+
+    s = Solution()
+if __name__ == "__main__":
+    s = Solution()
+    for test in [[1, 2, 3, 4, 5], [1, 2], []]:
+        ll = list_to_linkedlist(test)
+        reversed_ll = s.reverseList(ll)
+        print(linkedlist_to_list(reversed_ll))