Adding solutions for Assignment 6

Author: tachyonlabs

README.md

@@ -206,3 +206,25 @@ I've done four Dynamic Programming problems on InterviewBit so far:
 And here's a GIF of my InterviewBit Dynamic Programming topic page:
 
 * [GIF of my InterviewBit Dynamic Programming topic page](https://github.com/tachyonlabs/CodePath-Alumni-Professional-Interview-Prep-Course/blob/master/interviewbit-dynamic-programming-topic.gif)
+
+## Assignment 6
+
+I did eleven more Dynamic Programming problems on InterviewBit:
+
+* Length of Longest Subsequence
+* Ways to Decode
+* Best Time to Buy and Sell Stocks III
+* Best Time to Buy and Sell Stocks I
+* Best Time to Buy and Sell Stocks II
+* Max Sum Without Adjacent Elements
+* Edit Distance
+* Longest Increasing Subsequence
+* Max Sum Path in Binary Tree
+* Unique Binary Search Trees II
+* Word Break
+
+And here's a GIF of my updated InterviewBit Dynamic Programming topic page:
+
+* GIF of my updated InterviewBit Dynamic Programming topic page
+
+I took the "CodePath Interview Prep - Unit 6" test on February 4, so you should have received it.

interviewbit-dynamic-programming-best-time-to-buy-and-sell-stocks-i.py

@@ -0,0 +1,13 @@
+class Solution:
+    # @param A : tuple of integers
+    # @return an integer
+    def maxProfit(self, A):
+        if not A or len(A) < 2:
+            return 0
+
+        max_so_far = max_ending_here = A[1] - A[0]
+        for i in range(2, len(A)):
+            max_ending_here = max(max_ending_here + A[i] - A[i - 1], A[i] - A[i - 1])
+            max_so_far = max(max_so_far, max_ending_here)
+
+        return max(max_so_far, 0)

interviewbit-dynamic-programming-best-time-to-buy-and-sell-stocks-ii.py

@@ -0,0 +1,16 @@
+class Solution:
+    # @param A : tuple of integers
+    # @return an integer
+    def maxProfit(self, A):
+        max_p = 0
+        own = False
+        bought_price = None
+        for i in range(len(A)):
+            if not own and i != len(A) - 1 and A[i + 1] > A[i]:
+                own = True
+                bought_price = A[i]
+            elif own and (i == len(A) - 1 or A[i + 1] < A[i]):
+                own = False
+                max_p += A[i] - bought_price
+
+        return max_p

interviewbit-dynamic-programming-best-time-to-buy-and-sell-stocks-iii.py

@@ -0,0 +1,31 @@
+class Solution:
+    # @param A : tuple of integers
+    # @return an integer
+    def maxProfit(self, A):
+        if not A or len(A) < 2:
+            return 0
+
+        maxes = [[0 for i in range(len(A))] for j in range(2)]
+
+        # modified Kadane's
+        maxes[0][1] = max_ending_here = max_so_far = A[1] - A[0]
+        for i in range(2, len(A)):
+            max_ending_here = max(max_ending_here + A[i] - A[i - 1], A[i] - A[i -1])
+            max_so_far = max(max_so_far, max_ending_here)
+            maxes[0][i] = max_so_far
+
+        if maxes[0][-1] <= 0:
+            return 0
+
+        if len(A) < 4:
+            return maxes[0][-1]
+
+        max_diff = -A[0]
+
+        for i in range(1, len(A)):
+            max_for_one_or_two = max(maxes[1][i - 1], A[i] + max_diff)
+            maxes[1][i] = max_for_one_or_two
+            max_diff = max(max_diff, maxes[0][i] - A[i])
+
+        # a workaround for some kind of bug I still have, maxes[1][-1] should be enough :-(
+        return max(maxes[0][-1], maxes[1][-1])

interviewbit-dynamic-programming-edit-distance.py

@@ -0,0 +1,20 @@
+class Solution:
+    # @param A : string
+    # @param B : string
+    # @return an integer
+    def minDistance(self, A, B):
+        dp_table = []
+        dp_table.append([i for i in range(len(A) + 1)])
+        for i in range(1, len(B) + 1):
+            dp_table.append([i] + [0] * len(A))
+
+        A, B = " " + A, " " + B
+
+        for b in range(1, len(B)):
+            for a in range(1, len(A)):
+                if A[a] != B[b]:
+                    dp_table[b][a] = min(dp_table[b][a - 1], dp_table[b - 1][a], dp_table[b - 1][a - 1]) + 1
+                else:
+                    dp_table[b][a] = dp_table[b - 1][a - 1]
+
+        return dp_table[-1][-1]

interviewbit-dynamic-programming-length-of-longest-subsequence.py

@@ -0,0 +1,21 @@
+class Solution:
+    # @param A : tuple of integers
+    # @return an integer
+    def longestSubsequenceLength(self, A):
+        inc = [1] * len(A)
+        dec = inc[:]
+        for i in range(1, len(A)):
+            for j in range(0, i):
+                if A[j] < A[i]:
+                    inc[i] = max(inc[i], inc[j] + 1)
+        for i in range(len(A) - 2, -1, -1):
+            for j in range(len(A) - 1, i, -1):
+                if A[j] < A[i]:
+                    dec[i] = max(dec[i], dec[j] + 1)
+
+        longest = 0
+
+        for i in range(len(A)):
+            longest = max(longest, inc[i] + dec[i] - 1)
+
+        return longest

interviewbit-dynamic-programming-longest-increasing-subsequence.py

@@ -0,0 +1,11 @@
+class Solution:
+    # @param A : tuple of integers
+    # @return an integer
+    def lis(self, A):
+        counts = [1] * len(A)
+        for i in range(1, len(A)):
+            for j in range(0, i):
+                if A[j] < A[i]:
+                    counts[i] = max(counts[i], counts[j] + 1)
+
+        return max(counts)

interviewbit-dynamic-programming-max-sum-path-in-binary-tree.py

@@ -0,0 +1,27 @@
+# Definition for a  binary tree node
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    # @param A : root node of tree
+    # @return an integer
+    def get_max_path_sum(self, node):
+        if not node:
+            return 0
+
+        left_max_sum_path = self.get_max_path_sum(node.left)
+        right_max_sum_path = self.get_max_path_sum(node.right)
+
+        max_with_one_or_no_child_paths = max(max(left_max_sum_path, right_max_sum_path) + node.val, node.val)
+        max_with_both_child_paths = max(max_with_one_or_no_child_paths,
+                                        left_max_sum_path + right_max_sum_path + node.val)
+        self.max_sum_path = max(self.max_sum_path, max_with_both_child_paths)
+        return max_with_one_or_no_child_paths
+
+    def maxPathSum(self, A):
+        self.max_sum_path = float("-inf")
+        self.get_max_path_sum(A)
+        return self.max_sum_path

interviewbit-dynamic-programming-max-sum-without-adjacent-elements.py

@@ -0,0 +1,12 @@
+class Solution:
+    # @param A : list of list of integers
+    # @return an integer
+    def adjacent(self, A):
+        A[0] = [max(A[0][i], A[1][i]) for i in range(len(A[0]))]
+        inclusive = exclusive = 0
+        for num in A[0]:
+            new_inclusive = max(inclusive, exclusive + num)
+            exclusive = max(exclusive, inclusive)
+            inclusive = new_inclusive
+
+        return max(inclusive, exclusive)

interviewbit-dynamic-programming-topic-2.gif

@@ -0,0 +1,7 @@
+import math
+
+class Solution:
+    # @param A : integer
+    # @return an integer
+    def numTrees(self, A):
+        return math.factorial(2 * A) / (math.factorial(A) * math.factorial(A + 1))

interviewbit-dynamic-programming-unique-binary-search-trees-ii.py

@@ -0,0 +1,26 @@
+import re
+
+class Solution:
+    # @param A : string
+    # @return an integer
+    def count_decodings(self, A, i):
+        if i >= len(A) - 1:
+            return 1
+        if self.counts[i] != -1:
+            return self.counts[i]
+        if A[i + 1] == "0":
+            count = self.count_decodings(A, i + 2)
+        elif A[i] > "2" or (A[i] == "2" and A[i + 1] > "6") or (i <= len(A) - 3 and A[i + 2] == "0"):
+            count = self.count_decodings(A, i + 1)
+        else:
+            count = self.count_decodings(A, i + 1) + self.count_decodings(A, i + 2)
+
+        self.counts[i] = count
+        return count
+
+    def numDecodings(self, A):
+        if A[0] == "0" or re.search("[0,3-9]0", A):
+            return 0
+
+        self.counts = [-1] * len(A)
+        return self.count_decodings(A, 0)

interviewbit-dynamic-programming-ways-to-decode.py

@@ -0,0 +1,26 @@
+class Solution:
+    # @param A : string
+    # @param B : list of strings
+    # @return an integer
+    def wordBreak(self, A, B):
+        min_word_len = float("inf")
+        max_word_len = float("-inf")
+        dictionary = {}
+        # putting the words in a hash for faster lookups, plus getting min and max word length
+        # so we don't waste time looking up substrings that are too small or too large
+        for word in B:
+            dictionary[word] = 1
+            min_word_len = min(min_word_len, len(word))
+            max_word_len = max(max_word_len, len(word))
+
+        # to keep track of positions where the substring to the left can be successfully divided into words
+        we_can_do_it_to_here = [False] * (len(A) + 1)
+        we_can_do_it_to_here[0] = True
+
+        for i in range(min_word_len, len(A) + 1):
+            for j in range(max(0, i - max_word_len), i - min_word_len + 1):
+                if we_can_do_it_to_here[j] and A[j:i] in dictionary:
+                    we_can_do_it_to_here[i] = True
+                    break
+
+        return int(we_can_do_it_to_here[-1])