Passed driver liceniceed test aye

Author: jameszu

Daily-challenge/Dec/27/README.md

@@ -1,24 +1,48 @@
-# Partition Equal Subset Sum
-Given a non-empty array nums containing only positive integers, find if the array can be partitioned into two subsets such that the sum of elements in both subsets is equal.
+# Jump Game IV
+
+Solution
+Given an array of integers arr, you are initially positioned at the first index of the array.
+
+In one step you can jump from index i to index:
+
+i + 1 where: i + 1 < arr.length.
+i - 1 where: i - 1 >= 0.
+j where: arr[i] == arr[j] and i != j.
+Return the minimum number of steps to reach the last index of the array.
+
+Notice that you can not jump outside of the array at any time.
 
 
 
 Example 1:
 
-Input: nums = [1,5,11,5]
-Output: true
-Explanation: The array can be partitioned as [1, 5, 5] and [11].
+Input: arr = [100,-23,-23,404,100,23,23,23,3,404]
+Output: 3
+Explanation: You need three jumps from index 0 --> 4 --> 3 --> 9. Note that index 9 is the last index of the array.
 Example 2:
 
-Input: nums = [1,2,3,5]
-Output: false
-Explanation: The array cannot be partitioned into equal sum subsets.
+Input: arr = [7]
+Output: 0
+Explanation: Start index is the last index. You don't need to jump.
+Example 3:
+
+Input: arr = [7,6,9,6,9,6,9,7]
+Output: 1
+Explanation: You can jump directly from index 0 to index 7 which is last index of the array.
+Example 4:
+
+Input: arr = [6,1,9]
+Output: 2
+Example 5:
+
+Input: arr = [11,22,7,7,7,7,7,7,7,22,13]
+Output: 3
 
 
 Constraints:
 
-1 <= nums.length <= 200
-1 <= nums[i] <= 100<br>
+1 <= arr.length <= 5 * 10^4
+-10^8 <= arr[i] <= 10^8<br>
 
 ## Idea
 Just do while loop and convert to decimal

Daily-challenge/Dec/29/README.md

@@ -1,37 +1,34 @@
-# Jump Game III
-Given an array of non-negative integers arr, you are initially positioned at start index of the array. When you are at index i, you can jump to i + arr[i] or i - arr[i], check if you can reach to any index with value 0.
+# Pseudo-Palindromic Paths in a Binary Tree
+Given a binary tree where node values are digits from 1 to 9. A path in the binary tree is said to be pseudo-palindromic if at least one permutation of the node values in the path is a palindrome.
 
-Notice that you can not jump outside of the array at any time.
+Return the number of pseudo-palindromic paths going from the root node to leaf nodes.
 
 
 
 Example 1:
 
-Input: arr = [4,2,3,0,3,1,2], start = 5
-Output: true
-Explanation: 
-All possible ways to reach at index 3 with value 0 are: 
-index 5 -> index 4 -> index 1 -> index 3 
-index 5 -> index 6 -> index 4 -> index 1 -> index 3 
+
+
+Input: root = [2,3,1,3,1,null,1]
+Output: 2 
+Explanation: The figure above represents the given binary tree. There are three paths going from the root node to leaf nodes: the red path [2,3,3], the green path [2,1,1], and the path [2,3,1]. Among these paths only red path and green path are pseudo-palindromic paths since the red path [2,3,3] can be rearranged in [3,2,3] (palindrome) and the green path [2,1,1] can be rearranged in [1,2,1] (palindrome).
 Example 2:
 
-Input: arr = [4,2,3,0,3,1,2], start = 0
-Output: true 
-Explanation: 
-One possible way to reach at index 3 with value 0 is: 
-index 0 -> index 4 -> index 1 -> index 3
+
+
+Input: root = [2,1,1,1,3,null,null,null,null,null,1]
+Output: 1 
+Explanation: The figure above represents the given binary tree. There are three paths going from the root node to leaf nodes: the green path [2,1,1], the path [2,1,3,1], and the path [2,1]. Among these paths only the green path is pseudo-palindromic since [2,1,1] can be rearranged in [1,2,1] (palindrome).
 Example 3:
 
-Input: arr = [3,0,2,1,2], start = 2
-Output: false
-Explanation: There is no way to reach at index 1 with value 0.
+Input: root = [9]
+Output: 1
 
 
 Constraints:
 
-1 <= arr.length <= 5 * 10^4
-0 <= arr[i] < arr.length
-0 <= start < arr.length<br>
+The given binary tree will have between 1 and 10^5 nodes.
+Node values are digits from 1 to 9.<br>
 
 ## Idea
 Just do while loop and convert to decimal

Daily-challenge/Dec/29/sol.py

@@ -1,23 +1,31 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
 class Solution:
-    def canReach(self, arr: List[int], start: int) -> bool:
-        n = len(arr)
+    def dfs(self, root):
+        if not root: return
 
-        idx = start
-        q = [start]
+        cur, pal = self.dict_freq[root.val], self.Pal
 
-        while q:
+        self.Pal = self.Pal - 1 if cur == 1 else self.Pal + 1
+        self.dict_freq[root.val] = (cur + 1) % 2
+        
+        if not root.left and not root.right and self.Pal <= 1:
+            self.Res += 1
+        
+        self.dfs(root.left)
+        self.dfs(root.right)
+            
+        self.Pal, self.dict_freq[root.val] = pal, cur
 
-            node = q.pop(0)
-            if arr[node] == 0:
-                return True
-            if arr[node] < 0:
-                continue
-                
-            for i in [node + arr[node], node - arr[node]]:
-                if 0 <= i < n:
-                    q.append(i)
-                    
-            arr[node] = -arr[node]
+    def pseudoPalindromicPaths (self, root):
+        self.dict_freq = defaultdict(int)
+        self.Pal, self.Res = 0, 0
+        self.dfs(root)
+        return self.Res
 
 
 

Daily-challenge/Dec/30/README.md

@@ -1,23 +1,40 @@
-# The Skyline Problem
+# Game of Life
+According to Wikipedia's article: "The Game of Life, also known simply as Life, is a cellular automaton devised by the British mathematician John Horton Conway in 1970."
 
-Solution
-A city's skyline is the outer contour of the silhouette formed by all the buildings in that city when viewed from a distance. Now suppose you are given the locations and height of all the buildings as shown on a cityscape photo (Figure A), write a program to output the skyline formed by these buildings collectively (Figure B).
+The board is made up of an m x n grid of cells, where each cell has an initial state: live (represented by a 1) or dead (represented by a 0). Each cell interacts with its eight neighbors (horizontal, vertical, diagonal) using the following four rules (taken from the above Wikipedia article):
 
-Buildings Skyline Contour
-The geometric information of each building is represented by a triplet of integers [Li, Ri, Hi], where Li and Ri are the x coordinates of the left and right edge of the ith building, respectively, and Hi is its height. It is guaranteed that 0 ≤ Li, Ri ≤ INT_MAX, 0 < Hi ≤ INT_MAX, and Ri - Li > 0. You may assume all buildings are perfect rectangles grounded on an absolutely flat surface at height 0.
+Any live cell with fewer than two live neighbors dies as if caused by under-population.
+Any live cell with two or three live neighbors lives on to the next generation.
+Any live cell with more than three live neighbors dies, as if by over-population.
+Any dead cell with exactly three live neighbors becomes a live cell, as if by reproduction.
+The next state is created by applying the above rules simultaneously to every cell in the current state, where births and deaths occur simultaneously. Given the current state of the m x n grid board, return the next state.
 
-For instance, the dimensions of all buildings in Figure A are recorded as: [ [2 9 10], [3 7 15], [5 12 12], [15 20 10], [19 24 8] ] .
+ 
 
-The output is a list of "key points" (red dots in Figure B) in the format of [ [x1,y1], [x2, y2], [x3, y3], ... ] that uniquely defines a skyline. A key point is the left endpoint of a horizontal line segment. Note that the last key point, where the rightmost building ends, is merely used to mark the termination of the skyline, and always has zero height. Also, the ground in between any two adjacent buildings should be considered part of the skyline contour.
+Example 1:
 
-For instance, the skyline in Figure B should be represented as:[ [2 10], [3 15], [7 12], [12 0], [15 10], [20 8], [24, 0] ].
 
-Notes:
+Input: board = [[0,1,0],[0,0,1],[1,1,1],[0,0,0]]
+Output: [[0,0,0],[1,0,1],[0,1,1],[0,1,0]]
+Example 2:
 
-The number of buildings in any input list is guaranteed to be in the range [0, 10000].
-The input list is already sorted in ascending order by the left x position Li.
-The output list must be sorted by the x position.
-There must be no consecutive horizontal lines of equal height in the output skyline. For instance, [...[2 3], [4 5], [7 5], [11 5], [12 7]...] is not acceptable; the three lines of height 5 should be merged into one in the final output as such: [...[2 3], [4 5], [12 7], ...]<br>
+
+Input: board = [[1,1],[1,0]]
+Output: [[1,1],[1,1]]
+ 
+
+Constraints:
+
+m == board.length
+n == board[i].length
+1 <= m, n <= 25
+board[i][j] is 0 or 1.
+ 
+
+Follow up:
+
+Could you solve it in-place? Remember that the board needs to be updated simultaneously: You cannot update some cells first and then use their updated values to update other cells.
+In this question, we represent the board using a 2D array. In principle, the board is infinite, which would cause problems when the active area encroaches upon the border of the array (i.e., live cells reach the border). How would you address these problems?<br>
 
 ## Idea
 Just do while loop and convert to decimal

Daily-challenge/Dec/31/README.md

@@ -0,0 +1,57 @@
+# Game of Life
+According to Wikipedia's article: "The Game of Life, also known simply as Life, is a cellular automaton devised by the British mathematician John Horton Conway in 1970."
+
+The board is made up of an m x n grid of cells, where each cell has an initial state: live (represented by a 1) or dead (represented by a 0). Each cell interacts with its eight neighbors (horizontal, vertical, diagonal) using the following four rules (taken from the above Wikipedia article):
+
+Any live cell with fewer than two live neighbors dies as if caused by under-population.
+Any live cell with two or three live neighbors lives on to the next generation.
+Any live cell with more than three live neighbors dies, as if by over-population.
+Any dead cell with exactly three live neighbors becomes a live cell, as if by reproduction.
+The next state is created by applying the above rules simultaneously to every cell in the current state, where births and deaths occur simultaneously. Given the current state of the m x n grid board, return the next state.
+
+ 
+
+Example 1:
+
+
+Input: board = [[0,1,0],[0,0,1],[1,1,1],[0,0,0]]
+Output: [[0,0,0],[1,0,1],[0,1,1],[0,1,0]]
+Example 2:
+
+
+Input: board = [[1,1],[1,0]]
+Output: [[1,1],[1,1]]
+ 
+
+Constraints:
+
+m == board.length
+n == board[i].length
+1 <= m, n <= 25
+board[i][j] is 0 or 1.
+ 
+
+Follow up:
+
+Could you solve it in-place? Remember that the board needs to be updated simultaneously: You cannot update some cells first and then use their updated values to update other cells.
+In this question, we represent the board using a 2D array. In principle, the board is infinite, which would cause problems when the active area encroaches upon the border of the array (i.e., live cells reach the border). How would you address these problems?<br>
+
+## Idea
+Just do while loop and convert to decimal
+
+## Code
+```python
+class Solution:
+    def getSkyline(self, buildings):
+        events = sorted([(L, -H, R) for L, R, H in buildings] + list({(R, 0, None) for _, R, _ in buildings}))
+        res, hp = [[0, 0]], [(0, float("inf"))]
+        for x, negH, R in events:
+            while x >= hp[0][1]: 
+                heapq.heappop(hp)
+            if negH: 
+                heapq.heappush(hp, (negH, R))
+            if res[-1][1] + hp[0][0]: 
+                res += [x, -hp[0][0]],
+        return res[1:]
+        
+```

Daily-challenge/Dec/31/sol.py

@@ -0,0 +1,13 @@
+class Solution:
+    def getSkyline(self, buildings):
+        events = sorted([(L, -H, R) for L, R, H in buildings] + list({(R, 0, None) for _, R, _ in buildings}))
+        res, hp = [[0, 0]], [(0, float("inf"))]
+        for x, negH, R in events:
+            while x >= hp[0][1]: 
+                heapq.heappop(hp)
+            if negH: 
+                heapq.heappush(hp, (negH, R))
+            if res[-1][1] + hp[0][0]: 
+                res += [x, -hp[0][0]],
+        return res[1:]
+