feat: add 2 more leetcode problems

Author: wislertt

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= find_k_closest_elements
+PROBLEM ?= alien_dictionary
 FORCE ?= 0
 COMMA := ,
 

README.md

@@ -9,6 +9,8 @@
 [![pypi](https://img.shields.io/pypi/v/leetcode-py-sdk.svg?color=blue)](https://pypi.python.org/pypi/leetcode-py-sdk)
 [![downloads](https://static.pepy.tech/personalized-badge/leetcode-py-sdk?period=total&units=international_system&left_color=grey&right_color=blue&left_text=pypi%20downloads)](https://pepy.tech/projects/leetcode-py-sdk)
 [![python](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue?logo=python)](https://github.com/wisarootl/leetcode-py/)
+[![Star ⭐](https://img.shields.io/github/stars/wisarootl/leetcode-py?style=flat&logo=github&color=ffcc00)](https://github.com/wisarootl/leetcode-py)
+[![Sponsor 💖](https://img.shields.io/badge/Sponsor-💖-pink?style=flat)](https://github.com/sponsors/wisarootl)
 
 A Python package to generate professional LeetCode practice environments. Features automated problem generation from LeetCode URLs, beautiful data structure visualizations (TreeNode, ListNode, GraphNode), and comprehensive testing with 10+ test cases per problem. Built with professional development practices including CI/CD, type hints, and quality gates.
 
@@ -298,3 +300,11 @@ make gen-all-problems              # Regenerate all problems (destructive)
 - **CI/CD**: GitHub Actions for testing, security, pre-commit hooks, and release automation
 
 Perfect for systematic coding interview preparation with professional development practices and enhanced debugging capabilities.
+
+## 💖 Support This Project
+
+[![Star ⭐](https://img.shields.io/github/stars/wisarootl/leetcode-py?style=flat&logo=github&color=ffcc00)](https://github.com/wisarootl/leetcode-py)
+[![Sponsor 💖](https://img.shields.io/badge/Sponsor-💖-pink?style=flat)](https://github.com/sponsors/wisarootl)
+
+If you find this project helpful, please consider **starring the repo ⭐** or **sponsoring my work 💖**.
+Your support helps me maintain and improve this project. Thank you!

leetcode/alien_dictionary/README.md

@@ -0,0 +1,45 @@
+# Alien Dictionary
+
+**Difficulty:** Hard
+**Topics:** Array, String, Depth-First Search, Breadth-First Search, Graph, Topological Sort
+**Tags:** grind-75, grind
+
+**LeetCode:** [Problem 269](https://leetcode.com/problems/alien-dictionary/description/)
+
+## Problem Description
+
+There is a new alien language that uses the English alphabet. However, the order among the letters is unknown to you.
+
+You are given a list of strings `words` from the alien language's dictionary, where the strings in `words` are **sorted lexicographically** by the rules of this new language.
+
+Return _a string of the unique letters in the new alien language sorted in **lexicographically increasing order** by the new language's rules. If there is no solution, return_ `""`\*. If there are multiple solutions, return **any of them\***.
+
+## Examples
+
+### Example 1:
+
+```
+Input: words = ["wrt","wrf","er","ett","rftt"]
+Output: "wertf"
+```
+
+### Example 2:
+
+```
+Input: words = ["z","x"]
+Output: "zx"
+```
+
+### Example 3:
+
+```
+Input: words = ["z","x","z"]
+Output: ""
+Explanation: The order is invalid, so return "".
+```
+
+## Constraints
+
+- `1 <= words.length <= 100`
+- `1 <= words[i].length <= 100`
+- `words[i]` consists of only lowercase English letters.

leetcode/alien_dictionary/__init__.py

@@ -0,0 +1,13 @@
+def run_alien_order(solution_class: type, words: list[str]):
+    implementation = solution_class()
+    return implementation.alien_order(words)
+
+
+def assert_alien_order(result: str, expected: str) -> bool:
+    if expected == "":
+        assert result == ""
+    else:
+        # Multiple valid solutions possible, check if result is valid
+        assert len(result) == len(expected)
+        assert set(result) == set(expected)
+    return True

leetcode/alien_dictionary/helpers.py

@@ -0,0 +1,29 @@
+# ---
+# jupyter:
+#   jupytext:
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.17.3
+#   kernelspec:
+#     display_name: leetcode-py-py3.13
+#     language: python
+#     name: python3
+# ---
+
+# %%
+from helpers import assert_alien_order, run_alien_order
+from solution import Solution
+
+# %%
+# Example test case
+words = ["wrt", "wrf", "er", "ett", "rftt"]
+expected = "wertf"
+
+# %%
+result = run_alien_order(Solution, words)
+result
+
+# %%
+assert_alien_order(result, expected)

leetcode/alien_dictionary/playground.py

@@ -0,0 +1,41 @@
+class Solution:
+
+    # Time: O(C) where C is total number of characters in all words
+    # Space: O(1) since at most 26 characters in alphabet
+    def alien_order(self, words: list[str]) -> str:
+        # Build adjacency list and in-degree count
+        adj: dict[str, set[str]] = {c: set() for word in words for c in word}
+        in_degree = {c: 0 for c in adj}
+
+        # Build graph by comparing adjacent words
+        for i in range(len(words) - 1):
+            w1, w2 = words[i], words[i + 1]
+            min_len = min(len(w1), len(w2))
+
+            # Check for invalid case: longer word is prefix of shorter word
+            if len(w1) > len(w2) and w1[:min_len] == w2[:min_len]:
+                return ""
+
+            # Find first different character and add edge
+            for j in range(min_len):
+                if w1[j] != w2[j]:
+                    if w2[j] not in adj[w1[j]]:
+                        adj[w1[j]].add(w2[j])
+                        in_degree[w2[j]] += 1
+                    break
+
+        # Topological sort using Kahn's algorithm
+        queue = [c for c in in_degree if in_degree[c] == 0]
+        result = []
+
+        while queue:
+            c = queue.pop(0)
+            result.append(c)
+
+            for neighbor in adj[c]:
+                in_degree[neighbor] -= 1
+                if in_degree[neighbor] == 0:
+                    queue.append(neighbor)
+
+        # Check for cycle (invalid ordering)
+        return "".join(result) if len(result) == len(in_degree) else ""

leetcode/alien_dictionary/solution.py

@@ -0,0 +1,39 @@
+import pytest
+
+from leetcode_py import logged_test
+
+from .helpers import assert_alien_order, run_alien_order
+from .solution import Solution
+
+
+class TestAlienDictionary:
+    def setup_method(self):
+        self.solution = Solution()
+
+    @logged_test
+    @pytest.mark.parametrize(
+        "words, expected",
+        [
+            (["wrt", "wrf", "er", "ett", "rftt"], "wertf"),
+            (["z", "x"], "zx"),
+            (["z", "x", "z"], ""),
+            (["z", "z"], "z"),
+            (["abc", "ab"], ""),
+            (["ab", "adc"], "abdc"),
+            (["ac", "ab", "zc", "zb"], "acbz"),
+            (["z"], "z"),
+            (["za", "zb", "ca", "cb"], "zcab"),
+            (["zy", "zx"], "zyx"),
+            (["a", "b", "ca", "cc"], "abc"),
+            (["abc", "bcd", "cde"], "abcde"),
+            (["a", "aa"], "a"),
+            (["ab", "abc"], "abc"),
+            (["abc", "ab"], ""),
+            (["a", "b", "c", "d"], "abcd"),
+            (["d", "c", "b", "a"], "dcba"),
+            (["ac", "ab", "b"], "acb"),
+        ],
+    )
+    def test_alien_order(self, words: list[str], expected: str):
+        result = run_alien_order(Solution, words)
+        assert_alien_order(result, expected)

leetcode/alien_dictionary/test_solution.py

@@ -0,0 +1,40 @@
+# Design In-Memory File System
+
+**Difficulty:** Hard
+**Topics:** Design, Trie, Hash Table, String
+**Tags:** grind
+
+**LeetCode:** [Problem 588](https://leetcode.com/problems/design-in-memory-file-system/description/)
+
+## Problem Description
+
+Design an in-memory file system to simulate the following functions:
+
+`ls`: Given a path in string format. If it is a file path, return a list that only contains this file's name. If it is a directory path, return the list of file and directory names **in this directory**. Your output (file and directory names together) should in **lexicographic order**.
+
+`mkdir`: Given a **directory path** that does not exist, you should make a new directory according to the path. If the middle directories in the path don't exist either, you should create them as well. This function has void return type.
+
+`addContentToFile`: Given a **file path** and **file content** in string format. If the file doesn't exist, you need to create that file containing given content. If the file already exists, you need to **append** given content to original content. This function has void return type.
+
+`readContentFromFile`: Given a **file path**, return its **content** in string format.
+
+## Examples
+
+### Example 1:
+
+![filesystem](https://assets.leetcode.com/uploads/2018/10/12/filesystem.png)
+
+```
+Input:
+["FileSystem","ls","mkdir","addContentToFile","ls","readContentFromFile"]
+[[],["/"],["a/b/c"],["/a/b/c/d","hello"],["/"],["/a/b/c/d"]]
+
+Output:
+[null,[],null,null,["a"],"hello"]
+```
+
+## Constraints
+
+- You can assume all file or directory paths are absolute paths which begin with `/` and do not end with `/` except that the path is just `"/"`.
+- You can assume that all operations will be passed valid parameters and users will not attempt to retrieve file content or list a directory or file that does not exist.
+- You can assume that all directory names and file names only contain lower-case letters, and same names won't exist in the same directory.