D. J.:

- Added the leetcode problem and solution for 2, 19, 21, 61, 82, 86, 92, 138, 141 and 146

Author: nobodyPerfecZ

README.md

@@ -15,7 +15,7 @@
             <img src="https://img.shields.io/badge/tests-passed-brightgreen">
         </a>
         <a>
-            <img src="https://img.shields.io/badge/coverage-97%25-brightgreen">
+            <img src="https://img.shields.io/badge/coverage-96%25-brightgreen">
         </a>
     </h1>
 </div>
@@ -25,18 +25,25 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 ## Leetcode Problems & Solutions 💻
 
 - [1 Two Sum](https://leetcode.com/problems/two-sum/description/)
+- [2 Add Two Numbers](https://leetcode.com/problems/add-two-numbers/description/)
+- [19 Remove Nth Node From End of List](https://leetcode.com/problems/remove-nth-node-from-end-of-list/description/)
 - [20 Valid Parentheses](https://leetcode.com/problems/valid-parentheses/description/)
+- [21 Merge Two Sorted Lists](https://leetcode.com/problems/merge-two-sorted-lists/description/)
 - [26 Remove Duplicates from Sorted Array](https://leetcode.com/problems/remove-duplicates-from-sorted-array/description/)
 - [27 Remove Element](https://leetcode.com/problems/remove-element/description/)
 - [45 Jump Game II](https://leetcode.com/problems/jump-game-ii/description/)
 - [49 Group Anagrams](https://leetcode.com/problems/group-anagrams/description/)
 - [55 Jump Game](https://leetcode.com/problems/jump-game/description/)
 - [56 Merge Intervals](https://leetcode.com/problems/merge-intervals/description/)
 - [57 Insert Interval](https://leetcode.com/problems/insert-interval/description/)
+- [61 Rotate List](https://leetcode.com/problems/rotate-list/description/)
 - [67 Add Binary](https://leetcode.com/problems/add-binary/description/)
 - [71 Simplify Path](https://leetcode.com/problems/simplify-path/description/)
 - [80 Remove Duplicates from Sorted Array II](https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/description/)
+- [82 Remove Duplicates from Sorted List II](https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii/description/)
+- [86 Partition List](https://leetcode.com/problems/partition-list/description/)
 - [88 Merge Sorted Array](https://leetcode.com/problems/merge-sorted-array/description/)
+- [92 Reverse Linked List II](https://leetcode.com/problems/reverse-linked-list-ii/description/)
 - [98 Validate Binary Search Tree](https://leetcode.com/problems/validate-binary-search-tree/description/)
 - [100 Same Tree](https://leetcode.com/problems/same-tree/description/)
 - [101 Symmetric Tree](https://leetcode.com/problems/symmetric-tree/description/)
@@ -54,6 +61,11 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [125 Valid Palindrome](https://leetcode.com/problems/valid-palindrome/description/)
 - [128 Longest Consecutive Sequence](https://leetcode.com/problems/longest-consecutive-sequence/description/)
 - [129 Sum Root to Leaf Numbers](https://leetcode.com/problems/sum-root-to-leaf-numbers/description/)
+- [136 Single Number](https://leetcode.com/problems/single-number/description/)
+- [137 Single Number II](https://leetcode.com/problems/single-number-ii/description/)
+- [138 Copy List with Random Pointer](https://leetcode.com/problems/copy-list-with-random-pointer/description/)
+- [141 Linked List Cycle](https://leetcode.com/problems/linked-list-cycle/description/)
+- [146 LRU Cache](https://leetcode.com/problems/lru-cache/description/)
 - [150 Evaluate Reverse Polish Notation](https://leetcode.com/problems/evaluate-reverse-polish-notation/description/)
 - [155 Min Stack](https://leetcode.com/problems/min-stack/description/)
 - [169 Majority Element](https://leetcode.com/problems/majority-element/description/)

awesome_python_leetcode/_117_populating_next_right_pointers_in_each_node_II.py

@@ -1,4 +1,77 @@
-from awesome_python_leetcode.tree import TreeNode
+from typing import List, Optional
+
+
+class TreeNode:
+    """Binary tree node with next pointers."""
+
+    def __init__(
+        self,
+        val: int = 0,
+        left: Optional["TreeNode"] = None,
+        right: Optional["TreeNode"] = None,
+        next: Optional["TreeNode"] = None,
+    ):
+        self.val = val
+        self.left = left
+        self.right = right
+        self.next = next
+
+    def __eq__(self, other: List[int]) -> bool:
+        """Compare the pointers to the next node."""
+        if self is None or other is None:
+            return True
+
+        cur = self
+        i = 0
+        while i < len(other):
+            if other[i] is None:
+                if cur is not None:
+                    return False
+                i += 1
+                if i < len(other):
+                    cur = TreeNode.find(self, other[i])
+                continue
+            else:
+                if cur.val != other[i]:
+                    return False
+                i += 1
+                cur = cur.next
+        return True
+
+    @staticmethod
+    def find(root: Optional["TreeNode"], val: int) -> Optional["TreeNode"]:
+        """Find a node with a given value."""
+        if root is None:
+            return None
+        elif root.val == val:
+            return root
+        else:
+            return TreeNode.find(root.left, val) or TreeNode.find(root.right, val)
+
+    @staticmethod
+    def build(levelorder: List[int]) -> "TreeNode":
+        """Build a binary tree from levelorder traversal."""
+        if not levelorder or levelorder[0] is None:
+            return None
+        root = TreeNode(levelorder[0])
+        queue = [root]
+
+        i = 1
+        while i < len(levelorder):
+            node = queue.pop(0)
+
+            # Left child
+            if i < len(levelorder) and levelorder[i] is not None:
+                node.left = TreeNode(levelorder[i])
+                queue.append(node.left)
+            i += 1
+
+            # Right child
+            if i < len(levelorder) and levelorder[i] is not None:
+                node.right = TreeNode(levelorder[i])
+                queue.append(node.right)
+            i += 1
+        return root
 
 
 class Solution:

awesome_python_leetcode/_138_copy_list_with_random_pointer.py

@@ -0,0 +1,96 @@
+from typing import List, Optional, Tuple
+
+
+class Node:
+    def __init__(self, x: int, next: "Node" = None, random: "Node" = None):
+        self.val = int(x)
+        self.next = next
+        self.random = random
+
+    def __hash__(self):
+        return hash(self.val)
+
+    def __eq__(self, other: "Node") -> bool:
+        n1, n2 = self, other
+        while n1 and n2:
+            if n1.val != n2.val:
+                return False
+            elif n1.random is None and n2.random:
+                return False
+            elif n1.random and n2.random is None:
+                return False
+            elif n1.random and n2.random and n1.random.val != n2.random.val:
+                return False
+            n1, n2 = n1.next, n2.next
+        if n1 is None and n2:
+            return False
+        if n1 and n2 is None:
+            return False
+        return True
+
+    @staticmethod
+    def build(values: List[Tuple[int, Optional[int]]]) -> "Node":
+        """Build a singly-linked list."""
+        if not values:
+            return None
+
+        # Step 1: Create all nodes without setting random pointers
+        nodes = [Node(x) for x, _ in values]
+
+        # Step 2: Set the `next` pointers
+        for i in range(len(nodes) - 1):
+            nodes[i].next = nodes[i + 1]
+
+        # Step 3: Set the `random` pointers
+        for i, (_, random_index) in enumerate(values):
+            if random_index is not None:
+                nodes[i].random = nodes[random_index]
+
+        return nodes[0]
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def copyRandomList(self, head: "Optional[Node]") -> "Optional[Node]":
+        """
+        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 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.
+
+        For example, if there are two nodes X and Y in the original list, where
+        X.random --> Y, then for the corresponding two nodes x and y in the copied
+        list, x.random --> y.
+
+        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.
+
+        Your code will only be given the head of the original linked list.
+        """
+        oldToCopy = {None: None}
+
+        cur = head
+        while cur:
+            copy = Node(cur.val)
+            oldToCopy[cur] = copy
+            cur = cur.next
+
+        cur = head
+        while cur:
+            copy = oldToCopy[cur]
+            copy.next = oldToCopy[cur.next]
+            copy.random = oldToCopy[cur.random]
+            cur = cur.next
+
+        return oldToCopy[head]

awesome_python_leetcode/_141_linked_list_cycle.py

@@ -0,0 +1,66 @@
+from typing import List, Optional
+
+
+class ListNode:
+    """Singly-linked list node."""
+
+    def __init__(self, val: int = 0, next: Optional["ListNode"] = None):
+        self.val = val
+        self.next = next
+
+    def __eq__(self, other: "ListNode") -> bool:
+        if self is None and other is None:
+            return True
+        elif self is None:
+            return False
+        elif other is None:
+            return False
+        else:
+            return self.val == other.val and self.next == other.next
+
+    @staticmethod
+    def build(values: List[int], pos: Optional[int] = None) -> "ListNode":
+        """Build a singly-linked list with cycle."""
+        if not values:
+            return None
+
+        i = 0
+        prev, head, cycle = None, None, None
+        for i, val in enumerate(values):
+            if i == 0:
+                head = ListNode(val=val)
+                prev = head
+            else:
+                node = ListNode(val=val)
+                prev.next = node
+                prev = node
+
+            if pos is not None and i == pos:
+                cycle = prev
+            elif pos is not None and i == len(values) - 1:
+                prev.next = cycle
+        return head
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def hasCycle(self, head: Optional[ListNode]) -> bool:
+        """
+        Given head, the head of a linked list, determine if the linked list has a cycle
+        in it.
+
+        There is a cycle in a linked list if there is some node in the list that can be
+        reached again by continuously following the next pointer. Internally, pos is
+        used to denote the index of the node that tail's next pointer is connected to.
+        Note that pos is not passed as a parameter.
+
+        Return true if there is a cycle in the linked list. Otherwise, return false.
+        """
+        i, j = head, head
+        while j and j.next:
+            i = i.next
+            j = j.next.next
+            if i is j:
+                return True
+        return False

awesome_python_leetcode/_146_lru_cache.py

@@ -0,0 +1,47 @@
+class Node:
+    def __init__(self, key, val, prev=None, next=None):
+        self.key = key
+        self.val = val
+        self.prev = prev
+        self.next = next
+
+
+class LRUCache:
+
+    def __init__(self, capacity: int):
+        self.cap = capacity
+        self.cache = {}
+
+        # left=LRU, right=MRU
+        self.left, self.right = Node(0, 0), Node(0, 0)
+        self.left.next, self.right.prev = self.right, self.left
+
+    def remove(self, node):
+        # Remove node from list
+        prev, nxt = node.prev, node.next
+        prev.next, nxt.prev = nxt, prev
+
+    def insert(self, node):
+        # Insert node at right
+        prev, nxt = self.right.prev, self.right
+        prev.next = nxt.prev = node
+        node.next, node.prev = nxt, prev
+
+    def get(self, key: int) -> int:
+        if key in self.cache:
+            self.remove(self.cache[key])
+            self.insert(self.cache[key])
+            return self.cache[key].val
+        return -1
+
+    def put(self, key: int, value: int) -> None:
+        if key in self.cache:
+            self.remove(self.cache[key])
+        self.cache[key] = Node(key, value)
+        self.insert(self.cache[key])
+
+        if len(self.cache) > self.cap:
+            # Remove from the list and delete the LRU from the hashmap
+            lru = self.left.next
+            self.remove(lru)
+            del self.cache[lru.key]

awesome_python_leetcode/_19_remove_nth_node_from_end_of_list.py

@@ -0,0 +1,26 @@
+from typing import Optional
+
+from awesome_python_leetcode.list import ListNode
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
+        """
+        Given the head of a linked list, remove the nth node from the end of the list
+        and return its head.
+        """
+        dummy = ListNode(0, head)
+        left, right = dummy, head
+
+        while n > 0 and right:
+            right = right.next
+            n -= 1
+
+        while right:
+            left = left.next
+            right = right.next
+
+        left.next = left.next.next
+        return dummy.next

awesome_python_leetcode/_21_merge_two_sorted_lists.py

@@ -0,0 +1,31 @@
+from typing import Optional
+
+from awesome_python_leetcode.list import ListNode
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def mergeTwoLists(
+        self,
+        list1: Optional[ListNode],
+        list2: Optional[ListNode],
+    ) -> Optional[ListNode]:
+        """
+        You are given the heads of two sorted linked lists list1 and list2.
+
+        Merge the two lists into one sorted list. The list should be made by splicing
+        together the nodes of the first two lists.
+
+        Return the head of the merged linked list.
+        """
+        if list1 is None and list2 is None:
+            return None
+        elif list1 is None:
+            return ListNode(list2.val, self.mergeTwoLists(None, list2.next))
+        elif list2 is None:
+            return ListNode(list1.val, self.mergeTwoLists(list1.next, None))
+        elif list1.val <= list2.val:
+            return ListNode(list1.val, self.mergeTwoLists(list1.next, list2))
+        else:
+            return ListNode(list2.val, self.mergeTwoLists(list1, list2.next))