Leetcode submissions

Author: theabbie

01-matrix.py

@@ -0,0 +1,36 @@
+import heapq
+
+class Solution:
+    def updateMatrix(self, mat: List[List[int]]) -> List[List[int]]:
+        dist = [[0 if cell == 0 else float('inf') for cell in row] for row in mat]
+        heap = []
+        deleted = {}
+        m = len(mat)
+        n = len(mat[0])
+        for i in range(m):
+            for j in range(n):
+                heapq.heappush(heap, (dist[i][j], i, j))
+        while len(heap) > 0:
+            currdist, i, j = heapq.heappop(heap)
+            while (currdist, i, j) in deleted and len(heap) > 0:
+                deleted[(currdist, i, j)] -= 1
+                if deleted[(currdist, i, j)] == 0:
+                    del deleted[(currdist, i, j)]
+                currdist, i, j = heapq.heappop(heap)
+            if i > 0 and dist[i - 1][j] > 1 + currdist:
+                deleted[(dist[i - 1][j], i - 1, j)] = deleted.get((dist[i - 1][j], i - 1, j), 0) + 1
+                dist[i - 1][j] = 1 + currdist
+                heapq.heappush(heap, (1 + currdist, i - 1, j))
+            if i < m - 1 and dist[i + 1][j] > 1 + currdist:
+                deleted[(dist[i + 1][j], i + 1, j)] = deleted.get((dist[i + 1][j], i + 1, j), 0) + 1
+                dist[i + 1][j] = 1 + currdist
+                heapq.heappush(heap, (1 + currdist, i + 1, j))
+            if j > 0 and dist[i][j - 1] > 1 + currdist:
+                deleted[(dist[i][j - 1], i, j - 1)] = deleted.get((dist[i][j - 1], i, j - 1), 0) + 1
+                dist[i][j - 1] = 1 + currdist
+                heapq.heappush(heap, (1 + currdist, i, j - 1))
+            if j < n - 1 and dist[i][j + 1] > 1 + currdist:
+                deleted[(dist[i][j + 1], i, j + 1)] = deleted.get((dist[i][j + 1], i, j + 1), 0) + 1
+                dist[i][j + 1] = 1 + currdist
+                heapq.heappush(heap, (1 + currdist, i, j + 1))
+        return dist

1-bit-and-2-bit-characters.py

@@ -0,0 +1,25 @@
+class Solution:
+    def isValid(self, bits, i):
+        if i == 0:
+            if bits[0] == 0:
+                return True
+            else:
+                return False
+        if i == 1:
+            if bits[0] == 1:
+                return True
+            elif bits[1] == 0:
+                return True
+            else:
+                return False
+        if bits[i - 1] == 1 and self.isValid(bits, i - 2):
+            return True
+        if bits[i] == 0 and self.isValid(bits, i - 1):
+            return True
+        return False
+    
+    def isOneBitCharacter(self, bits: List[int]) -> bool:
+        if len(bits) >= 2:
+            return self.isValid(bits, len(bits) - 2)
+        else:
+            return True

3sum.py

@@ -0,0 +1,26 @@
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        n = len(nums)
+        if n < 3:
+            return []
+        triplets = set()
+        nums.sort()
+        for i in range(n - 2):
+            a = nums[i]
+            start = i + 1
+            end = n - 1
+            while start < end:
+                b = nums[start]
+                c = nums[end]
+                total = a + b + c
+                if total == 0:
+                    triplets.add(tuple(sorted([a, b, c])))
+                    start += 1
+                    end -= 1
+                elif total > 0:
+                    end -= 1
+                else:
+                    start += 1
+        return [list(triplet) for triplet in triplets]
+                            
+                        

add-digits.py

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

add-to-array-form-of-integer.cpp

@@ -0,0 +1,26 @@
+class Solution {
+public:
+    vector<int> addToArrayForm(vector<int>& A, int K) {
+        int digit;
+        int carry = 0;
+        int tmp;
+        int i = 0;
+        int n = A.size();
+        int nd = K>0?floor(log10(K) + 1):1;
+        while (i != max(n,nd)) {
+            digit = K%10;
+            if (i>=n) A.insert(A.begin(),0);
+            n = A.size();
+            tmp = A[n-i-1]+digit+carry;
+            A[n-i-1] = tmp%10;
+            carry = tmp/10;
+            K = K/10;
+            i++;
+        }
+        if (carry == 1) {
+            A.insert(A.begin(),0);
+            A[0] = carry;
+        }
+        return A;
+    }
+};

array-partition-i.py

@@ -0,0 +1,8 @@
+class Solution:
+    def arrayPairSum(self, nums: List[int]) -> int:
+        nums.sort()
+        n = len(nums)
+        total = 0
+        for i in range(0, n, 2):
+            total += min(nums[i:i + 2])
+        return total

available-captures-for-rook.py

@@ -0,0 +1,16 @@
+class Solution:
+    def numRookCaptures(self, board: List[List[str]]) -> int:
+        for i in range(8):
+            for j in range(8):
+                if board[i][j] == 'R':
+                    ctr = 0
+                    for di, dj in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
+                        n = 0
+                        while i + n * di >= 0 and i + n * di < 8 and j + n * dj >= 0 and j + n * dj < 8:
+                            if board[i + n * di][j + n * dj] == 'B':
+                                break
+                            if board[i + n * di][j + n * dj] == 'p':
+                                ctr += 1
+                                break
+                            n += 1
+                    return ctr

backspace-string-compare.py

@@ -0,0 +1,15 @@
+class Solution:
+    def backspaceCompare(self, s: str, t: str) -> bool:
+        ss = ""
+        tt = ""
+        for c in s:
+            if c == "#":
+                ss = ss[:-1]
+            else:
+                ss += c
+        for c in t:
+            if c == "#":
+                tt = tt[:-1]
+            else:
+                tt += c
+        return ss == tt

binary-number-with-alternating-bits.py

@@ -0,0 +1,8 @@
+class Solution:
+    def hasAlternatingBits(self, n: int) -> bool:
+        bi = "{:b}".format(n)
+        for i, c in enumerate(bi):
+            if i > 0:
+                if c == bi[i - 1]:
+                    return False
+        return True

binary-search-tree-iterator.py

@@ -0,0 +1,31 @@
+# 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 BSTIterator:
+
+    def __init__(self, root: Optional[TreeNode]):
+        self.list = []
+        self.inorder(root)
+        self.i = -1
+        
+    def inorder(self, root):
+        if root:
+            self.inorder(root.left)
+            self.list.append(root.val)
+            self.inorder(root.right)
+
+    def next(self) -> int:
+        self.i += 1
+        return self.list[self.i]
+
+    def hasNext(self) -> bool:
+        return self.i < len(self.list) - 1
+
+
+# Your BSTIterator object will be instantiated and called as such:
+# obj = BSTIterator(root)
+# param_1 = obj.next()
+# param_2 = obj.hasNext()

binary-tree-inorder-traversal.py

@@ -0,0 +1,13 @@
+# 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 inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
+        if not root:
+            return []
+        left = self.inorderTraversal(root.left)
+        right = self.inorderTraversal(root.right)
+        return left + [root.val] + right

binary-tree-level-order-traversal.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 levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        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 [levels[l] for l in range(level + 1)]

binary-tree-postorder-traversal.py

@@ -0,0 +1,13 @@
+# 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 postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
+        if not root:
+            return []
+        left = self.postorderTraversal(root.left)
+        right = self.postorderTraversal(root.right)
+        return left + right + [root.val]

binary-tree-preorder-traversal.py

@@ -0,0 +1,13 @@
+# 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 preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
+        if not root:
+            return []
+        left = self.preorderTraversal(root.left)
+        right = self.preorderTraversal(root.right)
+        return [root.val] + left + right

binary-tree-pruning.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 hasOne(self, root):
+        if root:
+            if root.val == 1:
+                return True
+            if self.hasOne(root.left) or self.hasOne(root.right):
+                return True
+        return False
+    
+    def pruneTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        if not self.hasOne(root):
+            return None
+        root.left = self.pruneTree(root.left)
+        root.right = self.pruneTree(root.right)
+        return root

check-if-all-1s-are-at-least-length-k-places-away.py

@@ -0,0 +1,16 @@
+class Solution:
+    def kLengthApart(self, nums: List[int], k: int) -> bool:
+        minDist = float('inf')
+        prev = None
+        numOnes = 0
+        for i, num in enumerate(nums):
+            if num == 1:
+                numOnes += 1
+                if prev:
+                    minDist = min(minDist, i - prev - 1)
+                prev = i
+        if numOnes <= 1:
+            return True
+        if minDist == float('inf'):
+            return False
+        return minDist >= k

check-if-all-as-appears-before-all-bs.py

@@ -0,0 +1,14 @@
+class Solution:
+    def checkString(self, s: str) -> bool:
+        a = []
+        b = []
+        for i, c in enumerate(s):
+            if c == 'a':
+                a.append(i)
+            if c == 'b':
+                b.append(i)
+        for i in a:
+            for j in b:
+                if i > j:
+                    return False
+        return True

check-if-all-characters-have-equal-number-of-occurrences.py

@@ -0,0 +1,6 @@
+class Solution:
+    def areOccurrencesEqual(self, s: str) -> bool:
+        ctr = {}
+        for c in s:
+            ctr[c] = ctr.get(c, 0) + 1
+        return len(set(ctr.values())) == 1

check-if-array-is-sorted-and-rotated.py

@@ -0,0 +1,12 @@
+class Solution:
+    def check(self, nums: List[int]) -> bool:
+        n = len(nums)
+        pivot = 0
+        for i in range(1, n):
+            if nums[i] < nums[i - 1]:
+                pivot = i
+                break
+        for i in range(pivot, pivot + n - 1):
+            if nums[(i + 1) % n] < nums[i % n]:
+                return False
+        return True

check-if-binary-string-has-at-most-one-segment-of-ones.py

@@ -0,0 +1,12 @@
+class Solution:
+    def checkOnesSegment(self, s: str) -> bool:
+        s += "0"
+        segments = []
+        chunk = ""
+        for c in s:
+            if c == '0' and len(chunk) > 0:
+                segments.append(chunk)
+                chunk = ""
+            elif c == '1':
+                chunk += '1'
+        return len(segments) <= 1