feat: add 10 more leetcode problems (#161)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: Wisaroot Lertthaweedech <l.wisaroot@gmail.com>
Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: 3 people

.claude/.dev/check_problem_lists.py

@@ -2,13 +2,20 @@
 
 import sys
 from pathlib import Path
+from typing import TypedDict
 
 # Import the problem lists
 sys.path.append(str(Path(__file__).parent.parent.parent))
 from problem_lists import available_lists
 from problem_lists.utils import get_existing_problems
 
 
+class CheckResult(TypedDict):
+    have: set[int]
+    missing: set[int]
+    total: int
+
+
 def check_problem_list(tag_name, problem_tuples, existing_problems):
     """Check how many problems from a list are available."""
     problem_numbers = {num for num, _ in problem_tuples}
@@ -34,7 +41,7 @@ def check_problem_lists(tag_names=None):
     existing = get_existing_problems()
     print(f"Total existing problems in JSON: {len(existing)}")
 
-    results = {}
+    results: dict[str, CheckResult] = {}
 
     # Check each specified list
     for tag_name, problem_tuples in available_lists.items():

.github/workflows/security.yml

@@ -30,6 +30,6 @@ jobs:
               with:
                   fetch-depth: 0
 
-            - uses: gitleaks/gitleaks-action@ff98106e4c7b2bc287b24eaf42907196329070c7 # v2.3.9
+            - uses: gitleaks/gitleaks-action@e0c47f4f8be36e29cdc102c57e68cb5cbf0e8d1e # v3.0.0
               env:
                   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/test.yml

@@ -93,14 +93,14 @@ jobs:
 
             - name: upload-coverage-reports-to-codecov
               if: matrix.python-version == inputs.target_python_version && (github.event_name == 'push' || github.event.pull_request.head.repo.full_name == github.repository)
-              uses: codecov/codecov-action@57e3a136b779b570ffcdbf80b3bdc90e7fab3de2 # v6.0.0
+              uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # v7.0.0
               with:
                   fail_ci_if_error: true
                   token: ${{ secrets.CODECOV_TOKEN }}
                   verbose: true
 
             - name: sonarqube-scan
               if: matrix.python-version == inputs.target_python_version && (github.event_name == 'push' || github.event.pull_request.head.repo.full_name == github.repository)
-              uses: SonarSource/sonarqube-scan-action@59db25f34e16620e48ab4bb9e4a5dce155cb5432 # v8.0.0
+              uses: SonarSource/sonarqube-scan-action@713881670b6b3676cda39549040e2d88c70d582e # v8.2.0
               env:
                   SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

.gitignore

@@ -573,3 +573,5 @@ $RECYCLE.BIN/
 *.lnk
 
 # End of https://www.toptal.com/developers/gitignore/api/macos,windows,visualstudiocode,intellij+all,node,java,python,go,ssh,terragrunt,terraform
+
+.playwright-mcp

bakefile.py

@@ -18,7 +18,7 @@
 
 class MyBakebook(GitHubActionsTools, PythonLibSpace):
     ci: bool = False
-    problem: str = "powx_n"
+    problem: str = "copy_list_with_random_pointer"
 
     def lint(self) -> None:
         self.ctx.run("uv run python scripts/sort_tags.py")

leetcode/copy_list_with_random_pointer/README.md

@@ -0,0 +1,55 @@
+# Copy List with Random Pointer
+
+**Difficulty:** Medium
+**Topics:** Hash Table, Linked List
+**Tags:** neetcode-150
+
+**LeetCode:** [Problem 138](https://leetcode.com/problems/copy-list-with-random-pointer/description/)
+
+## Problem Description
+
+A linked list of length `n` is given such that each node contains an additional **random pointer**, which could point to any node in the list, or `null`.
+
+Construct a [**deep copy**](https://en.wikipedia.org/wiki/Object_copying#Deep_copy) of the list. The deep copy should consist of exactly `n` **brand new** nodes, where each new node has its value set to the value of its corresponding original node. Both the `next` and `random` pointer of the new nodes should point to new nodes in the copied list such that the pointers in the original list and copied list represent the same list state. **None of the pointers in the new list should point to nodes in the original list**.
+
+Return _the head of the copied linked list_.
+
+The linked list is represented in the input/output as a list of `n` nodes. Each node is represented as a pair of `[val, random_index]` where:
+
+- `val`: an integer representing `Node.val`
+- `random_index`: the index of the node (range from `0` to `n-1`) that the `random` pointer points to, or `null` if it does not point to any node.
+
+## Examples
+
+### Example 1:
+
+![Example 1](https://assets.leetcode.com/uploads/2019/12/18/e1.png)
+
+```
+Input: head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
+Output: [[7,null],[13,0],[11,4],[10,2],[1,0]]
+```
+
+### Example 2:
+
+![Example 2](https://assets.leetcode.com/uploads/2019/12/18/e2.png)
+
+```
+Input: head = [[1,1],[2,1]]
+Output: [[1,1],[2,1]]
+```
+
+### Example 3:
+
+![Example 3](https://assets.leetcode.com/uploads/2019/12/18/e3.png)
+
+```
+Input: head = [[3,null],[3,0],[3,null]]
+Output: [[3,null],[3,0],[3,null]]
+```
+
+## Constraints
+
+- 0 <= n <= 1000
+- -10^4 <= Node.val <= 10^4
+- Node.random is null or points to some node in the linked list.

leetcode/copy_list_with_random_pointer/__init__.py

@@ -0,0 +1,49 @@
+from .solution import Node
+
+
+def _build_random_list(nodes: list[list[int | None]]) -> Node | None:
+    if not nodes:
+        return None
+    created: list[Node] = []
+    for node_spec in nodes:
+        val = node_spec[0]
+        assert isinstance(val, int)
+        created.append(Node(val))
+    for i, node_spec in enumerate(nodes):
+        if i + 1 < len(created):
+            created[i].next = created[i + 1]
+        rand_idx = node_spec[1]
+        if rand_idx is not None:
+            created[i].random = created[rand_idx]
+    return created[0]
+
+
+def _serialize_random_list(head: Node | None) -> list[list[int | None]]:
+    index_by_id: dict[int, int] = {}
+    cur: Node | None = head
+    i = 0
+    while cur is not None:
+        index_by_id[id(cur)] = i
+        i += 1
+        cur = cur.next
+    result: list[list[int | None]] = []
+    cur = head
+    while cur is not None:
+        rand_idx = index_by_id[id(cur.random)] if cur.random is not None else None
+        result.append([cur.val, rand_idx])
+        cur = cur.next
+    return result
+
+
+def run_copy_random_list(solution_class: type, nodes: list[list[int | None]]):
+    implementation = solution_class()
+    head = _build_random_list(nodes)
+    copied = implementation.copy_random_list(head)
+    return _serialize_random_list(copied)
+
+
+def assert_copy_random_list(
+    result: list[list[int | None]], expected: list[list[int | None]]
+) -> bool:
+    assert result == expected
+    return True

leetcode/copy_list_with_random_pointer/helpers.py

@@ -0,0 +1,29 @@
+# ---
+# jupyter:
+#   jupytext:
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.19.3
+#   kernelspec:
+#     display_name: leetcode-py-py3.13
+#     language: python
+#     name: python3
+# ---
+
+# %%
+from helpers import assert_copy_random_list, run_copy_random_list
+from solution import Solution
+
+# %%
+# Example test case (each node is [val, random_index])
+nodes = [[7, None], [13, 0], [11, 4], [10, 2], [1, 0]]
+expected = [[7, None], [13, 0], [11, 4], [10, 2], [1, 0]]
+
+# %%
+result = run_copy_random_list(Solution, nodes)
+result
+
+# %%
+assert_copy_random_list(result, expected)

leetcode/copy_list_with_random_pointer/playground.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+
+class Node:
+    def __init__(self, x: int, next: Node | None = None, random: Node | None = None):
+        self.val = int(x)
+        self.next = next
+        self.random = random
+
+
+class Solution:
+    # Time: O(n)
+    # Space: O(1) extra (interweaves clones into the original list)
+    def copy_random_list(self, head: Node | None) -> Node | None:
+        if head is None:
+            return None
+
+        # Phase 1: insert each clone right after its original node
+        current: Node | None = head
+        while current is not None:
+            nxt = current.next
+            clone = Node(current.val, nxt)
+            current.next = clone
+            current = nxt
+
+        # Phase 2: wire each clone's random from its original's random
+        current = head
+        while current is not None:
+            clone = current.next
+            assert clone is not None
+            if current.random is not None:
+                rand_clone = current.random.next
+                assert rand_clone is not None
+                clone.random = rand_clone
+            current = clone.next
+
+        # Phase 3: detach clones, restore the original, return the copy head
+        current = head
+        copy_head = head.next
+        while current is not None:
+            clone = current.next
+            assert clone is not None
+            current.next = clone.next
+            tail = clone.next
+            clone.next = tail.next if tail is not None else None
+            current = current.next
+
+        return copy_head