Leetcode submissions

Author: theabbie

a-number-after-a-double-reversal.py

@@ -0,0 +1,9 @@
+class Solution:
+    def isSameAfterReversals(self, num: int) -> bool:
+        i = 0
+        if num == 0:
+            return True
+        while num % 10 == 0:
+            num = num // 10
+            i += 1
+        return i == 0

all-elements-in-two-binary-search-trees.py

@@ -0,0 +1,23 @@
+import heapq
+
+# 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 getAllElements(self, root1: TreeNode, root2: TreeNode) -> List[int]:
+        heap = []
+        paths = [root1, root2]
+        i = 0
+        while i < len(paths):
+            curr = paths[i]
+            if curr:
+                heapq.heappush(heap, curr.val)
+                if curr.left:
+                    paths.append(curr.left)
+                if curr.right:
+                    paths.append(curr.right)
+            i += 1
+        return heapq.nsmallest(len(heap), heap)

basic-calculator-ii.py

@@ -0,0 +1,44 @@
+class Solution:
+    def eval(self, a, op, b):
+        if op == '+':
+            return a + b
+        elif op == '-':
+            return a - b
+        elif op == '/':
+            return int(a / b)
+        elif op == '*':
+            return a * b
+    
+    def calculate(self, s: str) -> int:
+        s += " "
+        precedence = {
+            '*': 1,
+            '/': 1,
+            '+': 0,
+            '-': 0
+        }
+        numstack = []
+        opstack = []
+        chunk = ""
+        for c in s:
+            if c == " " or c in precedence:
+                if len(chunk) > 0:
+                    numstack.append(int(chunk))
+                    chunk = ""
+                if c in precedence:
+                    while len(opstack) > 0 and precedence[opstack[-1]] >= precedence[c]:
+                        currop = opstack.pop()
+                        b = numstack.pop()
+                        a = numstack.pop()
+                        res = self.eval(a, currop, b)
+                        numstack.append(res)
+                    opstack.append(c)
+            else:
+                chunk += c
+        while len(opstack) > 0:
+            currop = opstack.pop()
+            b = numstack.pop()
+            a = numstack.pop()
+            res = self.eval(a, currop, b)
+            numstack.append(res)
+        return numstack[0]

basic-calculator.py

@@ -0,0 +1,66 @@
+class Solution:
+    def eval(self, a, op, b):
+        if op == '+':
+            return a + b
+        elif op == '-':
+            return a - b
+        elif op == '/':
+            return int(a / b)
+        elif op == '*':
+            return a * b
+    
+    def calculate(self, s: str) -> int:
+        s += " "
+        precedence = {
+            '*': 1,
+            '/': 1,
+            '+': 0,
+            '-': 0
+        }
+        brackets = {
+            '(': 1,
+            ')': -1
+        }
+        numstack = []
+        opstack = []
+        chunk = ""
+        latestOpenBracket = True
+        for c in s:
+            if c == " " or c in precedence or c in brackets:
+                if len(chunk) > 0:
+                    numstack.append(int(chunk))
+                    chunk = ""
+                if c in brackets:
+                    if brackets[c] == 1:
+                        opstack.append('(')
+                        latestOpenBracket = True
+                    elif brackets[c] == -1:
+                        latestOpenBracket = False
+                        while opstack[-1] != '(':
+                            currop = opstack.pop()
+                            b = numstack.pop()
+                            a = numstack.pop()
+                            res = self.eval(a, currop, b)
+                            numstack.append(res)
+                        opstack.pop()
+                elif c in precedence:
+                    if latestOpenBracket:
+                        numstack.append(0)
+                    while len(opstack) > 0 and precedence.get(opstack[-1], -1) >= precedence[c]:
+                        currop = opstack.pop()
+                        b = numstack.pop()
+                        a = numstack.pop()
+                        res = self.eval(a, currop, b)
+                        numstack.append(res)
+                    opstack.append(c)
+                    latestOpenBracket = False
+            else:
+                chunk += c
+                latestOpenBracket = False
+        while len(opstack) > 0:
+            currop = opstack.pop()
+            b = numstack.pop()
+            a = numstack.pop()
+            res = self.eval(a, currop, b)
+            numstack.append(res)
+        return numstack[0]

capitalize-the-title.py

@@ -0,0 +1,6 @@
+class Solution:
+    def capitalizeTitle(self, title: str) -> str:
+        words = title.split()
+        words = [word.lower() for word in words]
+        words = [(word[0].upper() + word[1:]) if len(word) > 2 else word for word in words]
+        return " ".join(words)

car-pooling.py

@@ -0,0 +1,17 @@
+import bisect
+
+class Solution:
+    def carPooling(self, trips: List[List[int]], capacity: int) -> bool:
+        n = len(trips)
+        points = []
+        for i in range(n):
+            num, source, dest = trips[i]
+            bisect.insort(points, (source, num))
+            bisect.insort(points, (dest, -num))
+        k = len(points)
+        curr = 0
+        for i in range(k):
+            curr += points[i][1]
+            if curr > capacity:
+                return False
+        return True

check-if-it-is-a-good-array.py

@@ -0,0 +1,12 @@
+class Solution:
+    def gcd(self, a, b):
+        while b:
+            a, b = b, a % b
+        return a
+    
+    def isGoodArray(self, nums: List[int]) -> bool:
+        n = len(nums)
+        curr = nums[0]
+        for i in range(1, n):
+            curr = self.gcd(curr, nums[i])
+        return curr == 1

combine-two-tables.sql

@@ -0,0 +1 @@
+SELECT firstName, lastName, city, state from Person LEFT JOIN Address ON Person.personId = Address.personId;

count-square-sum-triples.py

@@ -0,0 +1,11 @@
+class Solution:
+    def countTriples(self, n: int) -> int:
+        exists = set()
+        for c in range(1, n + 1):
+            exists.add(c * c)
+        ctr = 0
+        for a in range(1, n + 1):
+            for b in range(1, n + 1):
+                if (a * a + b * b) in exists:
+                    ctr += 1
+        return ctr

detect-capital.py

@@ -0,0 +1,12 @@
+class Solution:
+    def detectCapitalUse(self, word: str) -> bool:
+        n = len(word)
+        caps = 0
+        for i in range(n):
+            if word[i].isupper():
+                caps += 1
+        if caps == 0 or caps == n:
+            return True
+        if caps == 1 and word[0].isupper():
+            return True
+        return False