[main] Added files

Author: cthacker-udel

pythonProblems/leetcode/hw4/answers.py

@@ -0,0 +1,26 @@
+from typing import List
+
+
+## problem1
+cost_memo = {}
+def max_rod_price_cost(n_len: int, prices: List[int], cost: int) -> int:
+    if n_len == 0:
+        return 0
+    if (n_len - 1) in cost_memo:
+        return cost_memo[n_len - 1]
+    max_cost = prices[n_len - 1] - cost
+    for i in range(1, n_len):
+        max_cost = max(max_cost, prices[n_len - 1], (prices[i] + max_rod_price_cost(n_len - i, prices, cost)) - cost)
+    cost_memo[n_len] = max_cost
+    return max_cost
+
+## problem2
+def lengthOfLIS(self, nums: List[int]) -> int:
+    dp = [1] * len(nums)
+    n = len(nums) - 1
+    dp[n] = 1
+    for i in range(len(nums) - 1, -1, -1):
+        for j in range(i + 1, len(nums)):
+            dp[i] = max(dp[i], 1 + dp[j] if nums[i] < nums[j] else 0)
+    return max(dp)
+

pythonProblems/leetcode/hw4/blutarsky.py

@@ -0,0 +1,7 @@
+
+from typing import List
+
+
+class Solution:
+    def stockec(self, prices: List[int]):
+        pass

pythonProblems/leetcode/hw4/stockec.py

@@ -0,0 +1,19 @@
+
+from typing import List
+
+### problem4
+class Solution:
+    def maxProfit(self, prices: List[int]):
+        ## start at back, and compute greatest stock value on kth day
+        min_amount = prices[0]
+        max_profit = 0
+        for i in range(len(prices) - 1):
+            min_amount = min(min_amount, prices[i])
+            max_profit = max(max_profit, prices[i] - min_amount)
+        return max_profit
+
+
+if __name__ == '__main__':
+    prices = [7,1,5,3,6,4]
+    sol = Solution()
+    print(sol.maxProfit(prices))

pythonProblems/leetcode/hw4/stocks.py

@@ -0,0 +1,18 @@
+from typing import List
+
+## problem 2
+class Solution:
+    def lengthOfLIS(self, nums: List[int]) -> int:
+        dp = [1] * len(nums)
+        n = len(nums) - 1
+        dp[n] = 1
+        for i in range(len(nums) - 1, -1, -1):
+            for j in range(i + 1, len(nums)):
+                dp[i] = max(dp[i], 1 + dp[j] if nums[i] < nums[j] else 0)
+        return max(dp)
+
+
+if __name__ == '__main__':
+    l = Solution()
+    print(l.lengthOfLIS([7,7,7,7,7,7,7]))
+    

pythonProblems/leetcode/longestIncreasingSubsequence.py

@@ -0,0 +1,25 @@
+class Solution:
+    def longestValidParentheses(self, paren: str) -> int:
+        stack = []
+        longest = 0
+        curr_len = 0
+        for elem in paren:
+            if elem == '(':
+                stack.append('(')
+            elif elem == ')':
+                if len(stack) == 0:
+                    longest = max(curr_len, longest)
+                    curr_len = 0
+                else:
+                    stack.pop()
+                    curr_len += 2
+                    if len(stack) == 0:
+                        longest = max(longest, curr_len)
+                        curr_len = 0
+        longest = max(longest, curr_len)
+        return longest
+
+            
+if __name__ == '__main__':
+    sol = Solution()
+    print(sol.longestValidParentheses(")()())"))

pythonProblems/leetcode/longestValidParenthesis.py

@@ -0,0 +1,65 @@
+
+import time
+from typing import List
+
+memo = {}
+
+def modifiedRodCut(n: int, prices: List[int], costs: List[int], ind = 0) -> int:
+    """
+    Modified rod cut algorithm
+
+    Args:
+        n (int): The rod length
+        costs (List[int]): The array of costs
+
+    Returns:
+        int: The maximum revenue from cutting rod of length n
+    """
+    if ind == n:
+        memo[ind] = prices[n]
+        return prices[n]
+    return max(prices[ind] - costs[ind], modifiedRodCut(n - (ind + 1), prices, costs, ind + 1))
+
+
+max_price_memo = {}
+def max_rod_price(n_len: int, prices: List[int]) -> int:
+    max_price = prices[n_len]
+    if n_len in max_price_memo:
+        return max_price_memo[n_len]
+    if n_len <= 1:
+        max_price_memo[n_len] = prices[n_len]
+        return prices[n_len]
+    for i in range(1, n_len):
+        max_price = max(max_price, max_rod_price(i, prices) + max_rod_price(n_len - i, prices))
+    max_price_memo[n_len] = max_price
+    return max_price
+
+def text_cut_rod(n, text_prices):
+    if n == 0:
+        return 0
+    q = float('-inf')
+    for i in range(1, n + 1):
+        q = max(q, text_prices[i] + text_cut_rod(n - i, text_prices))
+    return q
+
+### Problem 1
+cost_memo = {}
+def max_rod_price_cost(n_len: int, prices: List[int], cost: int) -> int:
+    if n_len == 0:
+        return 0
+    if (n_len - 1) in cost_memo:
+        return cost_memo[n_len - 1]
+    max_cost = prices[n_len - 1] - cost
+    for i in range(1, n_len):
+        max_cost = max(max_cost, prices[n_len - 1], (prices[i] + max_rod_price_cost(n_len - i, prices, cost)) - cost)
+    cost_memo[n_len] = max_cost
+    return max_cost
+### Problem 1
+
+
+if __name__ == '__main__':
+    PRICES = [1, 2, 4, 5, 6, 4, 7, 2, 5, 5]
+    print(max_rod_price_cost(9, PRICES, 2))
+
+
+

pythonProblems/leetcode/modifiedRodCut.py

@@ -0,0 +1,48 @@
+from typing import List
+
+
+class Solution:
+
+    def find_successor(self, nums: List[int], val: int) -> int:
+        sorted_nums = sorted([x for x in set(nums + [val])])
+        ind_ = sorted_nums.index(val)
+        if ind_ == len(sorted_nums) - 1:
+            ## no successor, return -1
+            return -1
+        return sorted_nums[ind_ + 1]
+
+    def nextPermutation(self, nums: List[int]) -> None:
+        print('arr = ', nums)
+        if sorted(nums)[::-1] == nums:
+            ## return to default
+            nums[:] = sorted(nums)
+        else:
+            for i in range(1, len(nums)):
+                sorted_section = sorted(nums[i:])[::-1]
+                if sorted_section == nums[i:]:
+                    ## swap second max with one before, find successor of previous index and replace
+                    successor = Solution.find_successor(self, sorted_section, nums[i - 1])
+                    successor_ind = sorted_section.index(successor)
+                    nums[i - 1], nums[i:] = successor, sorted(sorted_section[:successor_ind] + [nums[i - 1]] + sorted_section[successor_ind + 1:])
+                    return None
+            for j in range(len(nums) - 1, -1, -1):
+                if nums[j] > nums[j - 1]:
+                    nums[j - 1], nums[j] = nums[j], nums[j - 1]
+                    return None
+
+
+if __name__ == '__main__':
+    arr = [1, 3, 2]
+    arr2 = [1,2,3, 4, 5]
+    arr3 = [1,1,5]
+    arr4 = [3,2,1]
+    arr5 = [1, 2]
+    arr6 = [2,3,1]
+    arr7 = [5,4,7,5,3,2]
+    arr8 = [2,2,7,5,4,3,2,2,1]
+    arr9 = [1,5,1]
+    sol = Solution()
+    for eacharr in [arr, arr2, arr3, arr4, arr5, arr6, arr7, arr8, arr9]:
+        sol.nextPermutation(eacharr)
+    for eacharr in [arr, arr2, arr3, arr4, arr5, arr6, arr7, arr8, arr9]:
+        print(eacharr)