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

evaluate-division.py

@@ -0,0 +1,26 @@
+class Solution:
+    def calcEquation(self, equations: List[List[str]], values: List[float], queries: List[List[str]]) -> List[float]:
+        graph = {}
+        n = len(equations)
+        for i in range(n):
+            a, b = equations[i]
+            graph[a] = graph.get(a, []) + [(b, values[i])]
+            graph[b] = graph.get(b, []) + [(a, 1 / values[i])]
+        op = []
+        for c, d in queries:
+            found = False
+            paths = [(c, 1, {c})]
+            while len(paths) > 0:
+                curr, prod, visited = paths.pop()
+                if curr not in graph:
+                    break
+                if curr == d:
+                    op.append(prod)
+                    found = True
+                    break
+                for j, div in graph.get(curr, []):
+                    if j not in visited:
+                        paths.append((j, prod * div, visited.union({j})))
+            if not found:
+                op.append(-1.0)
+        return op

find-pivot-index.py

@@ -0,0 +1,14 @@
+class Solution:
+    def pivotIndex(self, nums: List[int]) -> int:
+        n = len(nums)
+        if n == 1:
+            return 0
+        total = sum(nums)
+        curr = 0
+        if curr * 2 == total - nums[0]:
+            return 0
+        for i in range(n - 1):
+            curr += nums[i]
+            if curr * 2 == total - nums[i + 1]:
+                return i + 1
+        return -1

find-the-middle-index-in-array.py

@@ -0,0 +1,14 @@
+class Solution:
+    def findMiddleIndex(self, nums: List[int]) -> int:
+        n = len(nums)
+        if n == 1:
+            return 0
+        total = sum(nums)
+        curr = 0
+        if curr * 2 == total - nums[0]:
+            return 0
+        for i in range(n - 1):
+            curr += nums[i]
+            if curr * 2 == total - nums[i + 1]:
+                return i + 1
+        return -1

find-the-town-judge.py

@@ -0,0 +1,11 @@
+class Solution:
+    def findJudge(self, n: int, trust: List[List[int]]) -> int:
+        trustedGraph = {}
+        trustingGraph = {}
+        for a, b in trust:
+            trustedGraph[b] = trustedGraph.get(b, 0) + 1
+            trustingGraph[a] = trustingGraph.get(a, 0) + 1
+        for i in range(1, n + 1):
+            if trustedGraph.get(i, 0) == n - 1 and trustingGraph.get(i, 0) == 0:
+                return i
+        return -1

fizz-buzz.py

@@ -0,0 +1,3 @@
+class Solution:
+    def fizzBuzz(self, n: int) -> List[str]:
+        return [[str(i), "Fizz", "Buzz", "FizzBuzz"][2 * int(i % 5 == 0) + int(i % 3 == 0)] for i in range(1, n + 1)]

generate-random-point-in-a-circle.py

@@ -0,0 +1,20 @@
+import random
+import math
+
+class Solution:
+
+    def __init__(self, radius: float, x_center: float, y_center: float):
+        self.r = radius
+        self.cx = x_center
+        self.cy = y_center
+
+    def randPoint(self) -> List[float]:
+        randRadius = self.r * math.sqrt(random.random())
+        randAngle = 2 * math.pi * random.random()
+        x = self.cx + randRadius * math.cos(randAngle)
+        y = self.cy + randRadius * math.sin(randAngle)
+        return [x, y]
+
+# Your Solution object will be instantiated and called as such:
+# obj = Solution(radius, x_center, y_center)
+# param_1 = obj.randPoint()

implement-stack-using-queues.py

@@ -0,0 +1,26 @@
+class MyStack:
+
+    def __init__(self):
+        self.stack = []
+
+    def push(self, x: int) -> None:
+        self.stack.append(x)
+
+    def pop(self) -> int:
+        if not self.empty():
+            return self.stack.pop()
+
+    def top(self) -> int:
+        if not self.empty():
+            return self.stack[-1]
+
+    def empty(self) -> bool:
+        return len(self.stack) == 0
+
+
+# Your MyStack object will be instantiated and called as such:
+# obj = MyStack()
+# obj.push(x)
+# param_2 = obj.pop()
+# param_3 = obj.top()
+# param_4 = obj.empty()

length-of-last-word.py

@@ -0,0 +1,13 @@
+class Solution:
+    def lengthOfLastWord(self, s: str) -> int:
+        s += " "
+        latest = None
+        chunk = ""
+        for c in s:
+            if c == " ":
+                if len(chunk) > 0:
+                    latest = chunk
+                chunk = ""
+            else:
+                chunk += c
+        return len(latest)

linked-list-random-node.py

@@ -0,0 +1,29 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+
+import random
+
+class Solution:
+
+    def __init__(self, head: Optional[ListNode]):
+        self.head = head
+
+    def getRandom(self) -> int:
+        res = self.head.val
+        n = 2
+        curr = self.head.next
+        while curr:
+            isSwap = random.randrange(0, n)
+            if isSwap == 0:
+                res = curr.val
+            curr = curr.next
+            n += 1
+        return res
+
+
+# Your Solution object will be instantiated and called as such:
+# obj = Solution(head)
+# param_1 = obj.getRandom()