[main] Added files

Author: cthacker-udel

csharpProblems/GetDrinkByProfession/obj/Debug/net6.0/GetDrinkByProfession.assets.cache

@@ -0,0 +1,42 @@
+from __future__ import annotations
+from typing import List
+
+class Task:
+    """
+    The Task class, represents an task with an required time
+    """
+
+    def __init__(self, id: int, required: int):
+        """
+        Constructs a new activity instance
+
+        Args:
+            id (int): The id of the task
+            required (int): Time required to complete
+        """
+        self.id = id
+        self.required = required
+
+    def to_string(self):
+        return f'[Id {self.id} | Required {self.required}]'
+
+    def to_string_total(self, total):
+        print(f'{self.to_string()} total {total}')
+
+def calculate_total_cost(tasks: List[Task]) -> float: ## couldn't we just sort the array of tasks?
+    ## sort tasks by
+    sorted_tasks = sorted(tasks, key=lambda x: x.required)
+    running_total = 0
+    for eachtask in sorted_tasks:
+        running_total = running_total + (eachtask.required + running_total)
+    print(running_total)
+    return running_total / len(tasks)
+        ## choose task, find most compatible, choosing the task involves finding it's least counterpart,
+        ## aka if a + (b + a) < b + (a + b), or if a = 3 and b = 5, we want 3 + 8 vs 5 + 8
+
+
+
+if __name__ == "__main__":
+    activity_values = [5, 3, 2, 1, 10]
+    activity_array = [Task(taskId, taskCost) for taskId, taskCost in enumerate(activity_values)]
+    print(calculate_total_cost(activity_array))

csharpProblems/GroupWhile/obj/Debug/net6.0/GroupWhile.assets.cache

@@ -1,21 +1,44 @@
 class Solution:
     def longestValidParentheses(self, s: str) -> int:
-        dp = [0] * len(s)
-        for i in range(len(s)):
-            if s[i] == ')':
-                if i - 1 < 0:
-                    continue
-                elif s[i - 1] == '(':
-                    dp[i] = dp[i - 2] + 2
-                elif i - dp[i - 1] - 1 < 0:
-                    continue
-                elif s[i - dp[i - 1] - 1] == '(':
-                    ## matching over the current pair
-                    dp[i] = dp[i - 1] + 2 + dp[i - dp[i - 1] - 2]
-        return max(dp)
-
+        sums = []
+        stack = []
+        count = 0
+        for ind, eachparen in enumerate(s):
+            if eachparen == '(':
+                stack.append('(')
+                count += 1
+                if ind < len(s) - 1 and len(stack) > 1 and len(s[ind + 1:]) < len(stack):
+                    print('in if', ind)
+                    sums.append(0)
+                    sums.append(count - len(stack))
+                    sums.append(0)
+                    stack = []
+                    count = 0
+            elif eachparen == ')':
+                if len(stack) == 1:
+                    stack.pop()
+                    sums.append(count + 1)
+                    count = 0
+                elif len(stack) > 0:
+                    stack.pop()
+                    count += 1
+                else:
+                    sums.append(0)
+        if len(stack) > 0:
+            sums.append(0)
+            sums.append(count - len(stack))
+        print(sums)
+        running_total = 0
+        running_sums = []
+        for eachnum in sums:
+            if eachnum == 0:
+                running_sums.append(running_total)
+                running_total = 0
+            else:
+                running_total += eachnum
+        running_sums.append(running_total)
+        return max(running_sums) if len(running_sums) > 0 else 0
 
 if __name__ == '__main__':
     sol = Solution()
-    print(sol.longestValidParentheses("(()))())("
-                                      ))
+    print(sol.longestValidParentheses("(()")) # 4

csharpProblems/Position/obj/Debug/net6.0/Position.assets.cache

@@ -0,0 +1,11 @@
+class NList:
+
+    def __init__(self):
+        occupied = 0
+        elements = []
+
+    def add_elem(self, elem: int):
+        elements = list(bin(elem)[2:])
+
+
+class 

csharpProblems/RemoveDuplicateWords/obj/Debug/net6.0/RemoveDuplicateWords.assets.cache

@@ -0,0 +1,19 @@
+from typing import List
+
+
+class Solution:
+    
+    def search(self, nums: List[int], target: int) -> int:
+        l = 0
+        r = len(nums) - 1
+        while l != r:
+            if nums[l] == target:
+                return l
+            elif nums[r] == target:
+                return r
+        return -1
+
+
+if __name__ == '__main__':
+    sol = Solution()
+    sol.search([4, 5, 6, 7, 0, 1, 2], 0)