[main] Added algos

Author: cthacker-udel

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,22 @@
+from typing import List
+
+
+class Solution:
+    def firstMissingPositive(self, nums: List[int]) -> int:
+        min_number = -1
+        max_number = -1
+        if 1 not in nums:
+            return 1
+        for eachnumber in nums:
+            if eachnumber < 0:
+                continue
+            else:
+                min_number = eachnumber if min_number == -1 else min(min_number, eachnumber)
+                max_number = eachnumber if max_number == -1 else max(max_number, eachnumber)
+        return max_number + 1 if min_number <= 1 else min_number - 1
+
+
+if __name__ == '__main__':
+    sol = Solution()
+    nums = [3, 4, -1, 1]
+    print(sol.firstMissingPositive(nums))

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))