Revise Folder Structure

Author: brianchiang-tw

No_1_Two Sum/two_sum.py renamed to No_0001_Two Sum/two_sum.py

@@ -0,0 +1,54 @@
+'''
+
+Description:
+
+Given a collection of numbers that might contain duplicates, return all possible unique permutations.
+
+Example:
+
+Input: [1,1,2]
+Output:
+[
+  [1,1,2],
+  [1,2,1],
+  [2,1,1]
+]
+
+'''
+
+
+class Solution:
+    # @param num, a list of integer
+    # @return a list of lists of integers
+    
+    def permuteUnique(self, num):
+        length = len(num)
+        if length == 0: return []
+        if length == 1: return [num]
+        
+        # pre-processing
+        
+        num.sort()
+        res = []
+        previousNum = None
+        for i in range(length):
+            if num[i] == previousNum: continue
+            previousNum = num[i]
+            for j in self.permuteUnique(num[:i] + num[i+1:]):
+                res.append([num[i]] + j)
+        return res
+
+
+def test_bench():
+
+    test_data = [1,1,2]
+
+    print( Solution().permuteUnique(test_data) )
+
+    return
+
+
+
+if __name__ == '__main__':
+
+    test_bench()

No_1_Two Sum/two_sum_desciption.txt renamed to No_0001_Two Sum/two_sum_desciption.txt

@@ -0,0 +1,24 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def pathSum(self, root, s): 
+        if not root:
+            return []
+        res = []
+        stack = [(root, [root.val])]
+        while stack:
+            curr, ls = stack.pop()
+            if not curr.left and not curr.right and sum(ls) == s:
+                res.append(ls)
+            if curr.right:
+                stack.append((curr.right, ls+[curr.right.val]))
+            if curr.left:
+                stack.append((curr.left, ls+[curr.left.val]))
+        return res
+
+        

No_1_Two Sum/two_sum_story_preview.PNG renamed to No_0001_Two Sum/two_sum_story_preview.PNG

@@ -0,0 +1,79 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def check_path_sum( self, node: TreeNode, sum, path: List[int]):
+        
+        
+        
+        if node:
+            
+            if node.val == sum and node.left is None and node.right is None:
+                
+                cur_path = path + [ node.val ]
+                
+                #print("{} is meet, return {}". format( node.val, str([cur_path]) ) )
+                return True, [cur_path]
+            
+
+            else:
+                
+                next_path = path + [ node.val ]
+                
+                left_flag, left_sol = self.check_path_sum( node.left, sum-node.val, next_path)
+                right_flag, right_sol = self.check_path_sum( node.right, sum-node.val, next_path)
+                    
+                path_container = [ ]
+                
+                #print("\n\n current node value: {}".format(node.val))
+                #print("left flag = {}, left sol={}".format( left_flag, left_sol) )
+                #print("right flag = {}, right sol={}".format( right_flag, right_sol) )
+            
+                if left_flag is True and right_flag is True:
+                    
+                    path_container += [  p for p in left_sol ]
+                    path_container += [  p for p in right_sol ]
+                    
+                    #print("return path container: {}".format( path_container) )
+                    return True, path_container[:]
+                    
+                elif left_flag is True:
+                    
+                    sol_and_cur = [  p for p in left_sol ]
+                    #print("sol and cur: {}".format( sol_and_cur ) )
+                    
+                    path_container += sol_and_cur
+                    
+                    #print("return path container: {}".format( path_container) )
+                    return True, path_container[:]
+                
+                elif right_flag is True:
+                    
+                    sol_and_cur = [  p for p in right_sol ]
+                    #print("sol and cur: {}".format( sol_and_cur ) )
+                          
+                    path_container += sol_and_cur
+                          
+                    #print("return path container: {}".format( path_container) )
+                    return True, path_container[:]
+                else:
+                    return False, []
+                
+        else:
+            # empty node or empty tree
+            return False, []
+    
+    
+    def pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:
+        
+        flag, solution = self.check_path_sum( root, sum, [] )
+        
+        if flag:
+            return solution
+        else:
+            return []
+        

No_2_Add Two Numbers/add_two_numbers.py renamed to No_0002_Add Two Numbers/add_two_numbers.py

@@ -0,0 +1,52 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def check_path_sum( self, node: TreeNode, sum, path: List[int], solution):
+        
+        if node is None:
+            # empty tree
+            return
+
+        if node.val == sum and node.left is None and node.right is None:
+            
+            # get one solution meets summation requirement
+            # add current node to path
+            path += [ node.val ]
+            
+            # add current path to solution
+            solution += [ path[:] ]
+            
+            return
+        
+        else:
+            
+            # update sum for next level
+            sum -= node.val
+            
+            # add current node to path
+            path += [ node.val ]
+            
+            # dfs with left child
+            self.check_path_sum( node.left, sum, path[:], solution)
+            
+            # dfs with right child
+            self.check_path_sum( node.right, sum, path[:], solution)
+        
+            return
+        
+        
+    
+    def pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:
+        
+        solution = [] 
+        
+        self.check_path_sum( root, sum, [], solution )
+        
+        return solution
+        
+        

No_2_Add Two Numbers/add_two_numbers_description.txt renamed to No_0002_Add Two Numbers/add_two_numbers_description.txt

@@ -0,0 +1,24 @@
+from collections import deque
+
+class Solution:
+    def diStringMatch(self, S: str) -> List[int]:
+        
+        numbers = deque( list( range( len(S)+1 ) ) )
+        
+        output = []
+        
+        for ch in S:
+            
+            if ch == 'I':
+                # Increaing, select min, and push it into output
+                output.append( numbers.popleft() )
+                
+            else:
+                # Decreasing, select Max, and push it into output
+                output.append( numbers.pop() )
+                
+    
+        # last element
+        output.append( numbers.pop() )
+        
+        return output