Adding solution os 105, 106, 112, 113, 115, 123, 125, 139 problems

Author: Garvit244

100-200q/105.py

@@ -0,0 +1,49 @@
+'''
+	Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, determine if s can be segmented into a space-separated sequence of one or more dictionary words.
+
+	Note:
+
+	The same word in the dictionary may be reused multiple times in the segmentation.
+	You may assume the dictionary does not contain duplicate words.
+	Example 1:
+
+	Input: s = "leetcode", wordDict = ["leet", "code"]
+	Output: true
+	Explanation: Return true because "leetcode" can be segmented as "leet code".
+'''
+
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def buildTree(self, preorder, inorder):
+        """
+        :type preorder: List[int]
+        :type inorder: List[int]
+        :rtype: TreeNode
+        """
+        self.index = 0
+        def recursive(preorder, inorder, start, end):
+        	if start > end:
+        		return None
+
+        	node = TreeNode(preorder[self.index])
+        	self.index += 1
+        	if start == end:
+        		return node
+
+        	search_index = 0
+        	for i in range(start, end+1):
+        		if inorder[i] == node.val:
+        			search_index = i
+        			break
+
+        	node.left = recursive(preorder, inorder, start, search_index-1)
+        	node.right = recursive(preorder, inorder, search_index+1, end)
+        	return node
+
+        return recursive(preorder, inorder, 0, len(inorder)-1)

100-200q/106.py

@@ -0,0 +1,53 @@
+'''
+	Given inorder and postorder traversal of a tree, construct the binary tree.
+
+	Note:
+	You may assume that duplicates do not exist in the tree.
+
+	For example, given
+
+	inorder = [9,3,15,20,7]
+	postorder = [9,15,7,20,3]
+	Return the following binary tree:
+
+	    3
+	   / \
+	  9  20
+	    /  \
+	   15   7
+ '''
+
+ # Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def buildTree(self, inorder, postorder):
+        """
+        :type inorder: List[int]
+        :type postorder: List[int]
+        :rtype: TreeNode
+        """
+        self.index = len(inorder)-1
+        def recursive(postorder, inorder, start, end):
+        	if start > end:
+        		return None
+
+        	node = TreeNode(postorder[self.index])
+        	self.index -= 1
+        	if start == end:
+        		return node
+
+        	search_index = 0
+        	for i in range(start, end+1):
+        		if inorder[i] == node.val:
+        			search_index = i
+        			break
+        	node.right = recursive(postorder, inorder, search_index+1, end)
+        	node.left = recursive(postorder, inorder, start, search_index-1)
+        	return node
+
+        return recursive(postorder, inorder, 0, len(inorder)-1)

100-200q/112.py

@@ -0,0 +1,40 @@
+'''
+	Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.
+
+	Note: A leaf is a node with no children.
+
+	Example:
+
+	Given the below binary tree and sum = 22,
+
+	      5
+	     / \
+	    4   8
+	   /   / \
+	  11  13  4
+	 /  \      \
+	7    2      1
+'''
+
+
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def hasPathSum(self, root, sum):
+        """
+        :type root: TreeNode
+        :type sum: int
+        :rtype: bool
+        """
+        if not root:
+        	return False
+
+        if not root.left and not root.right and root.val == sum:
+        	return True
+
+        return self.hasPathSum(root.left, sum-root.val) or self.hasPathSum(root.right, sum-root.val)

100-200q/113.py

@@ -0,0 +1,58 @@
+'''
+	Given a binary tree and a sum, find all root-to-leaf paths where each path's sum equals the given sum.
+
+	Note: A leaf is a node with no children.
+
+	Example:
+
+	Given the below binary tree and sum = 22,
+
+	      5
+	     / \
+	    4   8
+	   /   / \
+	  11  13  4
+	 /  \    / \
+	7    2  5   1
+	Return:
+
+	[
+	   [5,4,11,2],
+	   [5,8,4,5]
+	]
+
+'''
+
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def pathSum(self, root, sum):
+        """
+        :type root: TreeNode
+        :type sum: int
+        :rtype: List[List[int]]
+        """
+        
+        result = []
+
+        def dfs(root, curr_sum, sum, path, result):
+        	if not root:
+        		return
+
+        	curr_sum += root.val
+        	if curr_sum == sum and not root.left and not root.right:
+        		result.append(path + [root.val])
+        		return
+
+        	if root.left:
+        		dfs(root.left, curr_sum, sum, path + [root.val], result)
+        	if root.right:
+        		dfs(root.right, curr_sum, sum, path + [root.val], result)
+
+        dfs(root, 0, sum, [], result)
+        return result

100-200q/115.py

@@ -0,0 +1,50 @@
+'''
+    Given a string S and a string T, count the number of distinct subsequences of S which equals T.
+
+    A subsequence of a string is a new string which is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, "ACE" is a subsequence of "ABCDE" while "AEC" is not).
+
+    Example 1:
+
+    Input: S = "rabbbit", T = "rabbit"
+    Output: 3
+    Explanation:
+
+    As shown below, there are 3 ways you can generate "rabbit" from S.
+    (The caret symbol ^ means the chosen letters)
+
+    rabbbit
+    ^^^^ ^^
+    rabbbit
+    ^^ ^^^^
+    rabbbit
+    ^^^ ^^^
+'''
+
+class Solution(object):
+    def numDistinct(self, s, t):
+        """
+        :type s: str
+        :type t: str
+        :rtype: int
+        """
+
+        row, col = len(s), len(t)
+
+        if col > row:
+        	return 0
+
+        dp = [[0 for _ in range(col+1)] for _ in range(row+1)]
+
+        for r in range(row+1):
+        	for c in range(col+1):
+        		if r == 0 and c == 0:
+        			dp[r][c] = 1
+        		elif r == 0:
+        			dp[r][c] = 0
+        		elif c == 0:
+        			dp[r][c] = 1
+        		else:
+        			dp[r][c] = dp[r-1][c]
+        			if s[r-1] == t[c-1]:
+        				dp[r][c] += dp[r-1][c-1]
+        return dp[row][col] 

100-200q/120.py

@@ -0,0 +1,39 @@
+'''
+    Given a triangle, find the minimum path sum from top to bottom. Each step you may move to adjacent numbers on the row below.
+
+    For example, given the following triangle
+
+    [
+         [2],
+        [3,4],
+       [6,5,7],
+      [4,1,8,3]
+    ]
+    The minimum path sum from top to bottom is 11 (i.e., 2 + 3 + 5 + 1 = 11).
+'''
+
+class Solution(object):
+    def minimumTotal(self, triangle):
+        """
+        :type triangle: List[List[int]]
+        :rtype: int
+        """
+        length = len(triangle)
+        columns = len(triangle[length-1])
+        
+        matrix = [[ 0 for col in range(columns)] for row in range(length)]
+        row_index = 0
+        
+        for row in range(length):
+            elements = triangle[row]
+            col_index = 0
+            
+            for val in elements:
+                matrix[row_index][col_index] = val
+                col_index += 1
+            row_index += 1
+            
+        for row in range(length-2, -1, -1):
+            for col in range(row+1):
+                matrix[row][col] += min(matrix[row+1][col+1], matrix[row+1][col])
+        return matrix[0][0]

100-200q/123.py

@@ -0,0 +1,33 @@
+'''
+	Say you have an array for which the ith element is the price of a given stock on day i.
+
+	Design an algorithm to find the maximum profit. You may complete at most two transactions.
+
+	Note: You may not engage in multiple transactions at the same time (i.e., you must sell the stock before you buy again).
+
+	Example 1:
+
+	Input: [3,3,5,0,0,3,1,4]
+	Output: 6
+	Explanation: Buy on day 4 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.
+	             Then buy on day 7 (price = 1) and sell on day 8 (price = 4), profit = 4-1 = 3.
+
+'''
+
+class Solution(object):
+    def maxProfit(self, prices):
+        """
+        :type prices: List[int]
+        :rtype: int
+        """
+        if len(prices) < 2:
+        	return 0
+        dp = [[0 for _ in range(len(prices))] for _ in range(3)]
+        for i in range(1,3):
+        	maxDiff = -prices[0]
+        	for j in range(1,len(prices)):
+        		dp[i][j] = max(dp[i][j-1], prices[j] + maxDiff)
+        		maxDiff = max(maxDiff, dp[i-1][j] -prices[j])
+
+        return dp[2][len(prices)-1]
+

100-200q/125.py

@@ -0,0 +1,28 @@
+class Solution(object):
+    def numDistinct(self, s, t):
+        """
+        :type s: str
+        :type t: str
+        :rtype: int
+        """
+
+        row, col = len(s), len(t)
+
+        if col > row:
+        	return 0
+
+        dp = [[0 for _ in range(col+1)] for _ in range(row+1)]
+
+        for r in range(row+1):
+        	for c in range(col+1):
+        		if r == 0 and c == 0:
+        			dp[r][c] = 1
+        		elif r == 0:
+        			dp[r][c] = 0
+        		elif c == 0:
+        			dp[r][c] = 1
+        		else:
+        			dp[r][c] = dp[r-1][c]
+        			if s[r-1] == t[c-1]:
+        				dp[r][c] += dp[r-1][c-1]
+        return dp[row][col] 

100-200q/139.py

@@ -0,0 +1,29 @@
+'''
+	Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, determine if s can be segmented into a space-separated sequence of one or more dictionary words.
+
+	Note:
+
+	The same word in the dictionary may be reused multiple times in the segmentation.
+	You may assume the dictionary does not contain duplicate words.
+	Example 1:
+
+	Input: s = "leetcode", wordDict = ["leet", "code"]
+	Output: true
+	Explanation: Return true because "leetcode" can be segmented as "leet code".
+'''
+
+class Solution(object):
+    def wordBreak(self, s, wordDict):
+        """
+        :type s: str
+        :type wordDict: List[str]
+        :rtype: bool
+        """
+        dp = [False for _ in range(len(s)+1)]
+        dp[0] = True
+        for index in range(len(s)):
+        	for j in range(i, -1, -1):
+        		if dp[j] and s[j:i+1] in wordDict:
+        			dp[i+1] = True
+        			wordBreak
+        return dp[len(s)]