Leetcode submissions

Author: theabbie

add-binary.py

@@ -0,0 +1,20 @@
+class Solution:
+    def addBinary(self, a: str, b: str) -> str:
+        m = len(a)
+        n = len(b)
+        if m > n:
+            b = "0" * (m - n) + b
+        else:
+            a = "0" * (n - m) + a
+        op = []
+        k = max(m, n)
+        i = k - 1
+        carry = 0
+        while i >= 0:
+            currval = int(a[i]) + int(b[i]) + carry
+            op.insert(0, str(currval % 2))
+            carry = currval // 2
+            i -= 1
+        if carry > 0:
+            op.insert(0, "1")
+        return "".join(op)

add-digits.py

@@ -0,0 +1,9 @@
+class Solution:
+    def addDigits(self, num: int) -> int:
+        k = num % 9
+        if k == 0:
+            if num == 0:
+                return 0
+            return 9
+        else:
+            return k

add-two-numbers.py

@@ -9,10 +9,11 @@ def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode], carry=0)
             l1val = l1.val if l1 else 0
             l2val = l2.val if l2 else 0
             currval = l1val + l2val + carry
-            curr = ListNode(val = currval % 10)
-            curr.next = self.addTwoNumbers(l1.next if l1 else None, l2.next if l2 else None, carry = currval // 10)
+            curr = ListNode()
+            curr.val = currval % 10
+            curr.next = self.addTwoNumbers(l1.next if l1 else None, l2.next if l2 else None, carry=currval // 10)
             return curr
         else:
             if carry > 0:
-                return ListNode(val = carry)
+                return ListNode(val=carry)
             return None

all-paths-from-source-to-target.py

@@ -3,11 +3,13 @@ def allPathsSourceTarget(self, graph: List[List[int]]) -> List[List[int]]:
         n = len(graph)
         op = []
         paths = [([0], {0})]
-        while len(paths) > 0:
-            curr, visited = paths.pop()
+        i = 0
+        while i < len(paths):
+            curr, visited = paths[i]
             if curr[-1] == n - 1:
                 op.append(curr)
             for newcurr in graph[curr[-1]]:
                 if newcurr not in visited:
                     paths.append((curr + [newcurr], visited.union({newcurr})))
+            i += 1
         return op

arithmetic-slices.py

@@ -1,25 +1,17 @@
 class Solution:
     def numSlicesEndingHere(self, nums, i, n):
-        if i in self.cache:
-            return self.cache[i]
         if i < 2:
             return 0
         if i == 2:
             if nums[2] - nums[1] == nums[1] - nums[0]:
-                self.cache[i] = 1
                 return 1
-            self.cache[i] = 0
             return 0
         if nums[i] - nums[i - 1] == nums[i - 1] - nums[i - 2]:
-            val = 1 + self.numSlicesEndingHere(nums, i - 1, n)
-            self.cache[i] = val
-            return val
-        self.cache[i] = 0
+            return 1 + self.numSlicesEndingHere(nums, i - 1, n)
         return 0
 
     def numberOfArithmeticSlices(self, nums: List[int]) -> int:
         n = len(nums)
-        self.cache = {}
         ctr = 0
         for i in range(n):
             ctr += self.numSlicesEndingHere(nums, i, n)

arithmetic-subarrays.py

@@ -0,0 +1,15 @@
+class Solution:
+    def isAP(self, arr):
+        arr.sort()
+        n = len(arr)
+        d = arr[1] - arr[0]
+        for i in range(1, n - 1):
+            if arr[i + 1] - arr[i] != d:
+                return False
+        return True
+        
+    
+    def checkArithmeticSubarrays(self, nums: List[int], l: List[int], r: List[int]) -> List[bool]:
+        n = len(l)
+        return [self.isAP(nums[l[i]:r[i]+1]) for i in range(n)]
+            

array-nesting.py

@@ -0,0 +1,19 @@
+class Solution:
+    def DFS(self, nums, i, visited):
+        visited.add(i)
+        if nums[i] not in visited:
+            return self.DFS(nums, nums[i], visited)
+        else:
+            return (i, visited)
+    
+    def arrayNesting(self, nums: List[int]) -> int:
+        n = len(nums)
+        mlen = 0
+        visited = set()
+        for i in range(n):
+            if i not in visited:
+                start, l = self.DFS(nums, i, set())
+                end, l = self.DFS(nums, start, set())
+                visited.update(l)
+                mlen = max(mlen, len(l))
+        return mlen

assign-cookies.py

@@ -0,0 +1,14 @@
+class Solution:
+    def findContentChildren(self, g: List[int], s: List[int]) -> int:
+        g.sort()
+        s.sort()
+        n = len(s)
+        ctr = 0
+        for greed in g:
+            for i in range(n):
+                if s[i] != None:
+                    if s[i] >= greed:
+                        s[i] = None
+                        ctr += 1
+                        break
+        return ctr

average-of-levels-in-binary-tree.py

@@ -0,0 +1,21 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
+        if not root:
+            return []
+        queue = [(root, 0)]
+        levels = {}
+        level = 0
+        while len(queue) > 0:
+            curr, level = queue.pop(0)
+            levels[level] = levels.get(level, []) + [curr.val]
+            if curr.left:
+                queue.append((curr.left, level + 1))
+            if curr.right:
+                queue.append((curr.right, level + 1))
+        return [sum(levels[l])/len(levels[l]) for l in range(level + 1)]

average-salary-excluding-the-minimum-and-maximum-salary.py

@@ -0,0 +1,6 @@
+class Solution:
+    def average(self, salary: List[int]) -> float:
+        n = len(salary)
+        salary.sort()
+        total = sum(salary[1:-1])
+        return total / (n - 2)