Additional work

Author: Zanger67

README.md

@@ -0,0 +1,25 @@
+class Solution:
+    def maxLength(self, arr: List[str]) -> int:
+        arrTuples = []
+
+        for s in arr :
+            stringSet = set(s)
+            if len(s) == len(stringSet) :
+                arrTuples.append(stringSet)
+
+
+        self.maxx = 0
+        def helper(current: set(), toTry: List[Set[str]]) -> None :
+            self.maxx = max(self.maxx, len(current))
+            if not toTry :
+                return
+            
+            nextToTry = toTry.pop()
+            helper(current, toTry)
+            temp = nextToTry | current
+            if len(current) + len(nextToTry) == len(temp) :
+                helper(temp, toTry)
+            toTry.append(nextToTry)
+
+        helper(set(), arrTuples)
+        return self.maxx

my-submissions/m1239.py

@@ -0,0 +1,48 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def lowestCommonAncestor(self, root: 'TreeNode', nodes: 'List[TreeNode]') -> 'TreeNode':
+        if not nodes :
+            return None
+        if len(nodes) == 1 :
+            return nodes[0]
+
+        self.commonAncestors = set()
+        targetNodes = set(x.val for x in nodes)
+        self.found = len(nodes)
+        
+        def dfs(curr: 'TreeNode', currentSet: 'Set[TreeNode]', depth: int) -> None :
+            if not curr or not self.found :
+                return
+            currentSet.add((depth, curr))
+
+            if curr.val in targetNodes :
+                self.found -= 1
+                if not self.commonAncestors :
+                    for x in currentSet :
+                        self.commonAncestors = currentSet.copy()
+                self.commonAncestors &= currentSet
+                
+                # even if something's below us, none of 
+                # the inbetween nodes will matter
+                currentSet.remove((depth, curr))
+                return
+            
+            dfs(curr.left, currentSet, depth + 1)
+            dfs(curr.right, currentSet, depth + 1)
+            currentSet.remove((depth, curr))
+        
+        dfs(root, set(), 0)
+
+        depth, node = self.commonAncestors.pop()
+        while self.commonAncestors :
+            tempDepth, tempNode = self.commonAncestors.pop()
+            if tempDepth > depth :
+                depth, node = tempDepth, tempNode
+        
+        return node

my-submissions/m1676.py

@@ -0,0 +1,12 @@
+class Solution:
+    def taskSchedulerII(self, tasks: List[int], space: int) -> int:
+        day = 0
+        lastOccurance = {}
+
+        for i in range(len(tasks)) :
+            if tasks[i] in lastOccurance and day - lastOccurance[tasks[i]] < space :
+                day = lastOccurance[tasks[i]] + space
+            day += 1
+            lastOccurance[tasks[i]] = day
+
+        return day

my-submissions/m2365.py

@@ -0,0 +1,19 @@
+class Solution:
+    def maxDistToClosest(self, seats: List[int]) -> int:
+        maxx = 0
+        indx = 0
+
+        while not seats[indx] :
+            indx += 1
+        lastPerson = indx
+        maxx = lastPerson
+        
+        for i, seat in enumerate(seats) :
+            if seat :
+                if maxx < (i - lastPerson) // 2 :
+                    maxx = (i - lastPerson) // 2
+                lastPerson = i
+        
+        maxx = max(maxx, len(seats) - lastPerson - 1)
+
+        return maxx

my-submissions/m849.py

@@ -0,0 +1,3 @@
+class Solution:
+    def kClosest(self, points: List[List[int]], k: int) -> List[List[int]]:
+        return sorted(points, key=lambda x: sqrt(x[0]**2 + x[1]**2))[:k]