idk

Author: jameszu

Daily-challenge/2021/Jan/02/README.md

@@ -49,35 +49,27 @@ target node is a node from the original tree and is not null.<br>
 two ways, one is to use a list and cheat, or we can use standard while loop and extra space for the dummy nodes and etc.
 ## Code
 ```python
-# Definition for singly-linked list.
-# class ListNode:
-#     def __init__(self, val=0, next=None):
-#         self.val = val
-#         self.next = next
-class Solution:
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
 
-    def __init__(self, head: ListNode):
-        """
-        @param head The linked list's head.
-        Note that the head is guaranteed to be not null, so it contains at least one node.
-        """
-        self.range = []
-        while head:
-            self.range.append(head.val)
-            head = head.next
+class Solution:
+    def getTargetCopy(self, original: TreeNode, cloned: TreeNode, target: TreeNode) -> TreeNode:
+        if not original or not cloned:
+            return None
+        stack = []
+        stack += [(original,cloned)]
+        while stack:
+            org, clone = stack.pop()
 
-
-    def getRandom(self) -> int:
-        """
-        Returns a random node's value.
-        """
-        num = int(random.random() * len(self.range))
-        return self.range[num]
-        
-
-
-# Your Solution object will be instantiated and called as such:
-# obj = Solution(head)
-# param_1 = obj.getRandom()
+            if org == target:    
+                return clone
+            if org.left:
+                stack.append((org.left, clone.left))
+            if org.right:
+                stack.append((org.right, clone.right))
 
 ```

Daily-challenge/2021/Jan/02/sol.py

@@ -1,30 +1,22 @@
-# Definition for singly-linked list.
-# class ListNode:
-#     def __init__(self, val=0, next=None):
-#         self.val = val
-#         self.next = next
-class Solution:
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
 
-    def __init__(self, head: ListNode):
-        """
-        @param head The linked list's head.
-        Note that the head is guaranteed to be not null, so it contains at least one node.
-        """
-        self.range = []
-        while head:
-            self.range.append(head.val)
-            head = head.next
+class Solution:
+    def getTargetCopy(self, original: TreeNode, cloned: TreeNode, target: TreeNode) -> TreeNode:
+        if not original or not cloned:
+            return None
+        stack = []
+        stack += [(original,cloned)]
+        while stack:
+            org, clone = stack.pop()
 
-
-    def getRandom(self) -> int:
-        """
-        Returns a random node's value.
-        """
-        num = int(random.random() * len(self.range))
-        return self.range[num]
-        
-
-
-# Your Solution object will be instantiated and called as such:
-# obj = Solution(head)
-# param_1 = obj.getRandom()
+            if org == target:    
+                return clone
+            if org.left:
+                stack.append((org.left, clone.left))
+            if org.right:
+                stack.append((org.right, clone.right))

Daily-challenge/2021/Jan/03/README.md

@@ -1,48 +1,48 @@
-# Increasing Order Search Tree
-Given the root of a binary search tree, rearrange the tree in in-order so that the leftmost node in the tree is now the root of the tree, and every node has no left child and only one right child.
+# Beautiful Arrangement
+
+Solution
+Suppose you have n integers labeled 1 through n. A permutation of those n integers perm (1-indexed) is considered a beautiful arrangement if for every i (1 <= i <= n), either of the following is true:
+
+perm[i] is divisible by i.
+i is divisible by perm[i].
+Given an integer n, return the number of the beautiful arrangements that you can construct.
 
 
 
 Example 1:
 
-
-Input: root = [5,3,6,2,4,null,8,1,null,null,null,7,9]
-Output: [1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]
+Input: n = 2
+Output: 2
+Explanation: 
+The first beautiful arrangement is [1,2]:
+    - perm[1] = 1 is divisible by i = 1
+    - perm[2] = 2 is divisible by i = 2
+The second beautiful arrangement is [2,1]:
+    - perm[1] = 2 is divisible by i = 1
+    - i = 2 is divisible by perm[2] = 1
 Example 2:
 
-
-Input: root = [5,1,7]
-Output: [1,null,5,null,7]
+Input: n = 1
+Output: 1
 
 
 Constraints:
 
-The number of nodes in the given tree will be in the range [1, 100].
-0 <= Node.val <= 1000 <br>
+1 <= n <= 15<br>
 
 ## Idea
 Just a while loop or for loop is fine
 
 ## Code
 
 ```python
-# if this null node was a left child, tail is its parent
-        # if this null node was a right child, tail is its parent's parent
-        if not root: return tail
-
-        # recursive call, traversing left while passing in the current node as tail
-        res = self.increasingBST(root.left, root)
-
-        # we don't want the current node to have a left child, only a single right child
-        root.left = None
-
-        # we set the current node's right child to be tail
-        # what is tail? this part is important
-        # if the current node is a left child, tail will be its parent
-        # else if the current node is a right child, tail will be its parent's parent
-        root.right = self.increasingBST(root.right, tail)
-
-        # throughout the whole algorithm, res is the leaf of the leftmost path in the original tree
-        # its the smallest node and thus will be the root of the modified tree
-        return res
+class Solution:
+    def countArrangement(self, N: int) -> int:
+        def count(i, X):
+            if i == 1:
+                return 1
+            return sum(count(i - 1, X - {x})
+                       for x in X
+                       if x % i == 0 or i % x == 0)
+        return count(N, set(range(1, N + 1)))
 ```

Daily-challenge/2021/Jan/03/sol.py

@@ -1,19 +1,9 @@
-# if this null node was a left child, tail is its parent
-        # if this null node was a right child, tail is its parent's parent
-        if not root: return tail
-
-        # recursive call, traversing left while passing in the current node as tail
-        res = self.increasingBST(root.left, root)
-
-        # we don't want the current node to have a left child, only a single right child
-        root.left = None
-
-        # we set the current node's right child to be tail
-        # what is tail? this part is important
-        # if the current node is a left child, tail will be its parent
-        # else if the current node is a right child, tail will be its parent's parent
-        root.right = self.increasingBST(root.right, tail)
-
-        # throughout the whole algorithm, res is the leaf of the leftmost path in the original tree
-        # its the smallest node and thus will be the root of the modified tree
-        return res
+class Solution:
+    def countArrangement(self, N: int) -> int:
+        def count(i, X):
+            if i == 1:
+                return 1
+            return sum(count(i - 1, X - {x})
+                       for x in X
+                       if x % i == 0 or i % x == 0)
+        return count(N, set(range(1, N + 1)))