Add files via upload

Author: rai-abhi24

Baseball Game - Leetcode 682.py

@@ -0,0 +1,14 @@
+class Solution:
+    def calPoints(self, operations: List[str]) -> int:
+        stk = []
+
+        for op in operations:
+            if op == "+":
+                stk.append(stk[-1] + stk[-2])
+            elif op == "D":
+                stk.append(stk[-1] * 2)
+            elif op == "C":
+                stk.pop()
+            else:
+                stk.append(int(op))
+        return sum(stk)

Clone Graph - Leetcode 133.py

@@ -0,0 +1,27 @@
+from typing import Optional
+class Solution:
+    def cloneGraph(self, node: Optional["Node"]) -> Optional["Node"]:
+        if not node:
+            return None
+
+        start = node
+        o_to_n = {}
+        stk = [start]
+        visited = set()
+        visited.add(start)
+
+        while stk:
+            node = stk.pop()
+            o_to_n[node] = Node(val=node.val)
+
+            for nei in node.neighbors:
+                if nei not in visited:
+                    visited.add(nei)
+                    stk.append(nei)
+
+        for old_node, new_node in o_to_n.items():
+            for nei in old_node.neighbors:
+                new_nei = o_to_n[nei]
+                new_node.neighbors.append(new_nei)
+
+        return o_to_n[start]

Combination Sum - Leetcode 39.py

@@ -0,0 +1,22 @@
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        res, sol = [], []
+        nums = candidates
+        n = len(nums)
+
+        def backtrack(i, cur_sum):
+            if cur_sum == target:
+                res.append(sol[:])
+                return
+
+            if cur_sum > target or i == n:
+                return
+
+            backtrack(i + 1, cur_sum)
+
+            sol.append(nums[i])
+            backtrack(i, cur_sum + nums[i])
+            sol.pop()
+
+        backtrack(0, 0)
+        return res

Combinations - Leetcode 77.py

@@ -0,0 +1,21 @@
+class Solution:
+    def combine(self, n: int, k: int) -> List[List[int]]:
+        ans, sol = [], []
+
+        def backtrack(x):
+            if len(sol) == k:
+                ans.append(sol[:])
+                return
+
+            left = x
+            still_need = k - len(sol)
+
+            if left > still_need:
+                backtrack(x - 1)
+
+            sol.append(x)
+            backtrack(x - 1)
+            sol.pop()
+
+        backtrack(n)
+        return ans

Generate Parentheses - Leetcode 22.py

@@ -0,0 +1,20 @@
+class Solution:
+    def generateParenthesis(self, n: int) -> List[str]:
+        ans, sol = [], []
+
+        def backtrack(openn, close):
+            if len(sol) == 2 * n:
+                ans.append("".join(sol))
+                return
+            if openn < n:
+                sol.append("(")
+                backtrack(openn + 1, close)
+                sol.pop()
+
+            if openn > close:
+                sol.append(")")
+                backtrack(openn, close + 1)
+                sol.pop()
+
+        backtrack(0, 0)
+        return ans

Letter Combinations of a Phone Number - Leetcode 17.py

@@ -0,0 +1,32 @@
+class Solution:
+    def letterCombinations(self, digits: str) -> List[str]:
+        if digits == "":
+            return []
+
+        ans, sol = [], []
+        
+        letter_map = {
+            "2": "abc",
+            "3": "def",
+            "4": "ghi",
+            "5": "jkl",
+            "6": "mno",
+            "7": "pqrs",
+            "8": "tuv",
+            "9": "wxyz",
+        }
+        
+        n = len(digits)
+
+        def backtrack(i=0):
+            if i == n:
+                ans.append("".join(sol))
+                return
+
+            for letter in letter_map[digits[i]]:
+                sol.append(letter)
+                backtrack(i + 1)
+                sol.pop()
+
+        backtrack(0)
+        return ans

Max Area of Island - Leetcode 695.py

@@ -0,0 +1,19 @@
+class Solution:
+    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
+        m = len(grid)
+        n = len(grid[0])
+
+        def dfs(i, j):
+            if i < 0 or i >= m or j < 0 or j >= n or grid[i][j] != 1:
+                return 0
+            else:
+                grid[i][j] = 0
+                return 1 + dfs(i + 1, j) + dfs(i, j - 1) + dfs(i - 1, j) + dfs(i, j + 1)
+
+        max_area = 0
+        for i in range(m):
+            for j in range(n):
+                if grid[i][j] == 1:
+                    max_area = max(max_area, dfs(i, j))
+
+        return max_area

Maximum Number of Balloons - Leetcode 1189.py

@@ -0,0 +1,13 @@
+class Solution:
+    def maxNumberOfBalloons(self, text: str) -> int:
+        counter = defaultdict(int)
+        balloon = "balloon"
+        
+        for c in text:
+            if c in balloon:
+                counter[c] += 1
+        
+        if any(c not in counter for c in balloon):
+            return 0
+        else:
+            return min(counter["b"], counter["a"], counter["l"] // 2, counter["o"] // 2, counter["n"])

Number of Islands - Leetcode 200.py

@@ -0,0 +1,22 @@
+class Solution:
+    def numIslands(self, grid: List[List[str]]) -> int:
+        m, n = len(grid), len(grid[0])
+
+        def dfs(i, j):
+            if i < 0 or i >= m or j < 0 or j >= n or grid[i][j] != "1":
+                return
+            else:
+                grid[i][j] = "0"
+                dfs(i, j + 1)
+                dfs(i + 1, j)
+                dfs(i, j - 1)
+                dfs(i - 1, j)
+
+        num_islands = 0
+        for i in range(m):
+            for j in range(n):
+                if grid[i][j] == "1":
+                    num_islands += 1
+                    dfs(i, j)
+
+        return num_islands