Merge branch 'main' of https://github.com/cthacker-udel/ProgrammingProblems

Author: cthacker-udel

pythonProblems/dp/boxes.py

@@ -0,0 +1,39 @@
+
+from typing import List
+
+
+class Box:
+    def __init__(self, width, height, depth):
+        self.width = width
+        self.height = height
+        self.depth = depth
+
+
+def boxes(stack: List[Box]) -> int:
+    n = len(stack)
+    boxes: List[Box] = []
+    for eachbox in stack:
+        boxes.append(eachbox) ## the box
+        boxes.append(Box(min(eachbox.height, eachbox.depth), eachbox.width, max(eachbox.height, eachbox.depth))) ## the box rotated, with width as height, width as min(height, depth) and depth as min(height, depth)
+        boxes.append(Box(min(eachbox.height, eachbox.width), eachbox.depth, max(eachbox.height, eachbox.width))) ## the box rotated, with depth as height, width as min(height, width), and depth as min(height, width)
+    n *= 3
+
+    boxes.sort(key=lambda b: b.depth * b.width, reverse=True)
+
+    msh = [0] * n
+
+    for i in range(len(msh)):
+        msh[i] = boxes[i].height
+    
+    for i in range(1, n):
+        for j in range(0, i):
+            if boxes[i].width < boxes[j].width and boxes[i].depth < boxes[j].depth: ## if the current target box's width is less then the subproblem box width, and depth likewise
+                if msh[i] < msh[j] + boxes[i].height: ## we can make a taller combination if the current dp target solution is less then the smaller dp solution + the target box height
+                    msh[i] = msh[j] + boxes[i].height ## we assign the target problem the result of subproblem j's solution + the target box's height
+
+    return max(msh) ## return the max height, which is the last element in the dp table
+
+
+if __name__ == '__main__':
+    arr = [Box(6, 4, 7), Box(2, 1, 3), Box(5, 4, 6), Box(12, 10, 32)]
+    print(boxes(arr))

pythonProblems/dp/combinationSum.py

@@ -0,0 +1,43 @@
+from typing import List
+
+
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        sorted_candidates = sorted(candidates)
+        combos = self.find_combos(sorted_candidates, target)
+        filtered_combos = []
+        for eachcombo in combos:
+            if sorted(eachcombo) in filtered_combos:
+                continue
+            else:
+                filtered_combos.append(sorted(eachcombo))
+        print(filtered_combos)
+        return filtered_combos
+    
+    def find_combos(self, nums: List[int], target: int, curr_total_arr: List[int] = None, combos: List[List[int]] = None) -> List[List[int]]:
+        curr_total = 0
+        if curr_total_arr is None:
+            curr_total_arr = []
+        else:
+            curr_total = sum(curr_total_arr)
+        if combos is None:
+            combos = []
+        for eachnum in nums:
+            if eachnum + curr_total < target:
+                acquired_combos = self.find_combos(nums, target, curr_total_arr + [eachnum], combos)
+                for eachcombo in acquired_combos:
+                    if eachcombo not in combos:
+                        combos.append(eachcombo)
+            elif eachnum + curr_total > target:
+                return [] + combos
+            else:
+                if sorted(curr_total_arr + [eachnum]) not in combos and curr_total + eachnum == target:
+                    return combos + sorted([curr_total_arr + [eachnum]])
+                return []
+        return combos
+
+if __name__ == '__main__':
+    candidates = [36,21,2,3,23,24,38,22,11,14,15,25,32,19,35,26,31,13,34,29,12,37,17,20,39,30,40,28,27,33]
+    target = 35
+    sol = Solution()
+    sol.combinationSum(candidates, target)

pythonProblems/dp/combinationSumTwo.py

@@ -0,0 +1,39 @@
+from typing import List
+
+
+class Solution:
+    def combinationSum2(self, candidates: List[int], target: int, combos: List[List[int]] = None, curr_combo_sum: int = None, curr_combo: List[int] = None, curr_combo_indices: List[int] = None) -> List[List[int]]:
+        if sum(candidates) < target:
+            return []
+        if combos is None:
+            combos = []
+        if curr_combo is None:
+            curr_combo = []
+        if curr_combo_indices is None:
+            curr_combo_indices = []
+        
+        curr_combo_sum = 0
+        if not combos is None:
+            curr_combo_sum = sum(curr_combo)
+        
+        for ind, elem in enumerate(candidates):
+            if elem + curr_combo_sum > target:
+                continue
+            if elem + curr_combo_sum == target and ind not in curr_combo_indices:
+                combo_sorted = sorted(curr_combo + [elem])
+                if combo_sorted not in combos:
+                    combos.append(combo_sorted)
+            elif ind not in curr_combo_indices: 
+                acquired_combos = self.combinationSum2(candidates, target, combos, curr_combo_sum, curr_combo + [elem], curr_combo_indices + [ind])
+                for eachcombo in acquired_combos:
+                    eachcombo_sorted = sorted(eachcombo)
+                    if eachcombo_sorted not in combos:
+                        combos.append(eachcombo_sorted)
+        return combos
+
+if __name__ == '__main__':
+    sol = Solution()
+    candidates = [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]
+    target = 30
+    print(sol.combinationSum2(candidates, target))
+            

pythonProblems/dp/countAndSay.py

@@ -0,0 +1,38 @@
+
+class Solution:
+
+    def gen_number(self, num: str) -> str:
+        sequence_count = {}
+        curr_key = ''
+        generated_string = ''
+        for eachdigit in num:
+            if eachdigit in sequence_count:
+                sequence_count[eachdigit] += 1
+            elif len(sequence_count) == 0: ## initial case, when dict is empty
+                sequence_count[eachdigit] = 1
+                curr_key = eachdigit
+            else:
+                generated_string += str(sequence_count[curr_key]) + curr_key
+                curr_key = eachdigit
+                sequence_count.clear()
+                sequence_count[eachdigit] = 1
+        if len(sequence_count) > 0:
+            generated_string += str(sequence_count[curr_key]) + curr_key
+        return generated_string
+
+    def countAndSay(self, n: int) -> str:
+        if n == 1:
+            return '1'
+        else:
+            sequence_elements = ['1']
+            i = 0
+            while len(sequence_elements) < n:
+                sequence_elements.append(self.gen_number(sequence_elements[i]))
+                i += 1
+            print(sequence_elements)
+            return sequence_elements[n - 1]
+
+if __name__ == '__main__':
+    sol = Solution()
+    target = 5
+    sol.countAndSay(target)

pythonProblems/dp/firstMissingPositive.py

@@ -0,0 +1,60 @@
+import random
+from typing import List
+
+
+class Solution:
+    def firstMissingPositive(self, nums: List[int]) -> int:
+        min_number = -1
+        max_number = 0
+        gap_base = -1
+        for eachnum in nums:
+            if eachnum > 0:
+                if min_number == -1:
+                    ## initialize all trackers
+                    max_number = eachnum
+                    min_number = eachnum
+                else:
+                    gap = abs(eachnum - max_number)
+                    gap_base_diff = abs(eachnum - gap_base)
+                    if gap > 1 and ((eachnum > max_number and gap_base == -1) or (eachnum < max_number and gap_base == -1) or (eachnum < max_number and gap_base_diff == 1) or (eachnum < max_number and gap_base_diff > 0 and eachnum < gap_base)): ## before and after
+                        if gap_base_diff == 1:
+                            gap_base = eachnum
+                        elif gap_base == -1:
+                            gap_base = min(max_number, eachnum)
+                        else:
+                            gap_base = min(max_number, eachnum)
+                    min_number = min(min_number, eachnum)
+                    max_number = max(max_number, eachnum)
+        if min_number != 0 and min_number > 1:
+            return 1
+        if gap_base == -1:
+            ## no gaps detected, check max, if max is 0, return 1
+            if max_number == 0:
+                return 1
+            # return max + 1
+            return max_number + 1
+        else:
+            return gap_base + 1
+
+
+
+if __name__ == '__main__':
+    sol = Solution()
+    arrs = [
+        [1,2,0],
+        [3,4,-1,1],
+        [7,8,9,11,12],
+        [1, 2, 3, 50, 48, 5214, 32, 6324, 234, -32, -1231, -432134, -5123, -412243, -44, -324, 0],
+        [1, 2, 3, 6, 7, 4],
+        [40, 33, 50, -11, 0, 12, 50, 1, 33, -1, -3, 27, 29, -19],
+        [1,2,6,3,5,4]
+    ]
+    # for i in range(5):
+    #     new_arr = []
+    #     for j in range(random.randint(10, 30)):
+    #         new_arr.append(random.randint(-20, 50))
+    #     arrs.append(new_arr)
+    #     new_arr = []
+    for eacharr in arrs:
+        print('testing {}'.format(eacharr))
+        print(sol.firstMissingPositive(eacharr))

pythonProblems/dp/lcs.py

@@ -1,2 +1,83 @@
-def lcs(sub1: str, sub2: str) -> str:
-    pass
+from pprint import pprint
+from typing import List
+
+
+def find_subsequence_len(str1: str, str2: str, max_length=0) -> int:
+    for ind, elem in enumerate(str1):
+        if elem in str2:
+            max_length = max(
+                max_length, 1 + find_subsequence_len(str1[ind + 1:], str2[str2.index(elem) + 1:]))
+    return max_length
+
+
+def lcs(substr1: str, substr2: str) -> int:
+    while len(substr1) > 0 and len(substr2) > 0:
+        if substr1[-1] != substr2[-1]:
+            return max(lcs(substr1[:-1], substr2), lcs(substr1, substr2[:-1]))
+        return 1 + lcs(substr1[:-1], substr2[:-1])
+    return 0
+
+
+def print_lcs(substr1: str, substr2: str) -> str:
+    table = []
+    # initialize table
+    for _ in substr1 + " ":
+        table_row = []
+        for __ in substr2 + " ":
+            table_row.append(0)
+        table.append(table_row)
+        table_row = []
+
+    for i in range(1, len(substr1) + 1):
+        for j in range(1, len(substr2) + 1):
+            if substr2[j - 1] == substr1[i - 1]:  # if both characters match
+                # characters match, set the diagonal cell to the curr value + 1
+                table[i][j] = table[i - 1][j - 1] + 1
+            else:
+                # either up or left in the lookup table
+                table[i][j] = max(table[i - 1][j], table[i][j - 1])
+    # start at bottom right, and follow the path, taking a diagonal left with the letters are the same
+
+    startCol = len(table[len(table) - 1]) - 1
+    startRow = len(table) - 1
+
+    _substr1 = " " + substr1
+    _substr2 = " " + substr2
+    substr = ''
+    pprint(table)
+    while startCol != 0 and startRow != 0:
+        if _substr1[startRow] == _substr2[startCol]:
+            # jump diagonal, add letter
+            substr += _substr1[startRow]
+            startRow -= 1
+            startCol -= 1
+        else:
+            # evaluate left
+            left_ = -1
+            if startCol > 0:
+                left_ = table[startRow][startCol - 1]
+            # evaluate top
+            top_ = -1
+            if startRow > 0:
+                top_ = table[startRow - 1][startCol]
+
+            if left_ == top_:
+                startCol -= 1
+            if left_ != -1 and top_ != -1:
+                startRow -= 1 if top_ > left_ else 0
+                startCol -= 1 if left_ > top_ else 0
+            if left_ == -1:
+                # move up
+                startRow -= 1
+            if top_ == -1:
+                startCol -= 1
+    return substr[::-1]
+
+
+if __name__ == '__main__':
+    x = 'abcbdab'
+    y = 'bdcaba'
+    print(lcs(x, y))
+    x2 = 'xmjyauzadfsf'
+    y2 = 'mzjawxuwqrwe'
+    print(print_lcs(x2, y2))

pythonProblems/dp/longestSubstring.py

@@ -0,0 +1,50 @@
+from pprint import pprint
+
+def longestSubstring(substr1: str, substr2: str) -> str:
+    table = []
+    for _ in substr1:
+        table_row = []
+        for __ in substr2:
+            table_row.append(0)
+        table.append(table_row)
+        table_row = []
+    
+    for i in range(len(substr1)):
+        for j in range(len(substr2)):
+            if substr1[i] == substr2[j]:
+                if i == 0:
+                    table[i][j] = 1
+                elif j == 0:
+                    table[i][j] = 1
+                else:
+                    table[i][j] = table[i - 1][j - 1] + 1
+
+    coords = []
+    max_value = 0
+    for eachrow in table:
+        max_value = max(max_value, max(eachrow))
+    
+    for i in range(len(table)):
+        for j in range(len(table[i])):
+            if table[i][j] == max_value:
+                coords.append((i, j))
+
+    substrs = []
+    for eachcoord in coords:
+        x_ = eachcoord[1]
+        y_ = eachcoord[0]
+        substr = ''
+        while table[y_][x_] != 0 and x_ >= 0 and y_ >= 0:
+            substr += substr1[x_]
+            x_ -= 1
+            y_ -= 1
+        substrs.append(substr)
+    print(substrs)
+    
+    
+
+
+if __name__ == '__main__':
+    s1 = 'abab'
+    s2 = 'baba'
+    longestSubstring(s1, s2)

pythonProblems/dp/searchInsert.py

@@ -0,0 +1,26 @@
+from typing import List
+
+
+class Solution:
+    def searchInsert(self, nums: List[int], target: int) -> int:
+        mid = len(nums) // 2
+        l = 0
+        r = len(nums) - 1
+        while l < r:
+            if nums[mid] > target:
+                r = mid - 1
+            elif nums[mid] < target:
+                l = mid + 1
+            elif nums[mid] == target:
+                return mid
+            mid = l + ((r - l) // 2)
+        if l == -1 or r == -1:
+            return 0
+        return mid + 1 if nums[mid] < target else mid
+
+
+if __name__ == '__main__':
+    sol = Solution()
+    nums = [1, 3, 5, 6]
+    target = 0
+    print(sol.searchInsert(nums, target))