diff --git a/Problem1.py b/Problem1.py
new file mode 100644
index 00000000..a2754f01
--- /dev/null
+++ b/Problem1.py
@@ -0,0 +1,63 @@
+# 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
+
+# Time Complexity --> O(n)
+# Space Complexity --> O(n)
+class Solution:
+    def buildTree(self, inorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
+        
+        self.hmap = {}
+        for i in range(len(inorder)):
+            self.hmap[inorder[i]] = i
+        n = len(inorder)
+        self.idx = n-1
+        return self.helper(postorder, 0, n-1)
+    
+    def helper(self, postorder, st, end):
+        # base
+        if st>end:
+            return None
+
+        # logic
+        print(self.idx)
+        root_val = postorder[self.idx]
+        root_idx = self.hmap[root_val]
+        self.idx -= 1
+
+        root = TreeNode(root_val)
+        root.right = self.helper(postorder, root_idx+1, end)
+        root.left = self.helper(postorder, st, root_idx-1)
+
+        return root
+
+
+'''
+
+# Time Complexity --> O(n^2)
+# Space Complexity --> O(n^2)
+class Solution:
+    def buildTree(self, inorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
+        if not postorder:
+            return None
+        
+        root_val = postorder[-1]
+        hmap = {}
+        for i in range(len(inorder)):
+            hmap[inorder[i]] = i
+        root_idx = hmap[root_val]
+
+        inleft = inorder[:root_idx]
+        inright = inorder[root_idx+1:]
+        postleft = postorder[:len(inleft)]
+        postright = postorder[len(inleft):-1]
+
+        root = TreeNode(root_val)
+        root.left = self.buildTree(inleft, postleft)
+        root.right = self.buildTree(inright, postright)
+
+        return root
+'''
diff --git a/Problem2.py b/Problem2.py
new file mode 100644
index 00000000..b2e302af
--- /dev/null
+++ b/Problem2.py
@@ -0,0 +1,27 @@
+# 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
+# Time Complexity --> O(n) where n is the number of nodes
+# Space Complexity --> O(log n)
+class Solution:
+    def sumNumbers(self, root: Optional[TreeNode]) -> int:
+        return self.helper(root, 0)
+
+    def helper(self, root, curr):
+        # base
+        if root is None:
+            return 0
+        # logic
+        curr = curr * 10 + root.val
+
+        if root.left is None and root.right is None:
+            return curr 
+        left = self.helper(root.left, curr)
+        right = self.helper(root.right, curr)
+        return left + right 
+        
+        
+