Add files via upload

Author: rai-abhi24

Permutations - Leetcode 46.py

@@ -0,0 +1,18 @@
+class Solution:
+    def permute(self, nums: List[int]) -> List[List[int]]:
+        n = len(nums)
+        ans, sol = [], []
+
+        def backtrack():
+            if len(sol) == n:
+                ans.append(sol[:])
+                return
+
+            for x in nums:
+                if x not in sol:
+                    sol.append(x)
+                    backtrack()
+                    sol.pop()
+
+        backtrack()
+        return ans

Ransom Note - Leetcode 383.py

@@ -0,0 +1,19 @@
+class Solution:
+    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
+        counter = {}
+
+        for c in magazine:
+            if c in counter:
+                counter[c] += 1
+            else:
+                counter[c] = 1
+
+        for c in ransomNote:
+            if c not in counter:
+                return False
+            elif counter[c] == 1:
+                del counter[c]
+            else:
+                counter[c] -= 1
+
+        return True

Rotting Oranges - Leetcode 994.py

@@ -0,0 +1,35 @@
+from collections import deque
+class Solution:
+    def orangesRotting(self, grid: List[List[int]]) -> int:
+        EMPTY, FRESH, ROTTEN = 0, 1, 2
+        m, n = len(grid), len(grid[0])
+        num_fresh = 0
+        q = deque()
+
+        for i in range(m):
+            for j in range(n):
+                if grid[i][j] == ROTTEN:
+                    q.append((i, j))
+                elif grid[i][j] == FRESH:
+                    num_fresh += 1
+
+        if num_fresh == 0:
+            return 0
+
+        num_minutes = -1
+        while q:
+            q_size = len(q)
+            num_minutes += 1
+        
+            for _ in range(q_size):
+                i, j = q.popleft()
+                for r, c in [(i, j + 1), (i + 1, j), (i, j - 1), (i - 1, j)]:
+                    if 0 <= r < m and 0 <= c < n and grid[r][c] == FRESH:
+                        grid[r][c] = ROTTEN
+                        num_fresh -= 1
+                        q.append((r, c))
+
+        if num_fresh == 0:
+            return num_minutes
+        else:
+            return -1

Search Insert Position - Leetcode 35.py

@@ -0,0 +1,20 @@
+class Solution:
+    def searchInsert(self, nums: List[int], target: int) -> int:
+        n = len(nums)
+        l = 0
+        r = n - 1
+
+        while l <= r:
+            m = (l + r) // 2
+            
+            if nums[m] < target:
+                l = m + 1
+            elif nums[m] > target:
+                r = m - 1
+            else:
+                return m
+
+        if nums[m] < target:
+            return m + 1
+        else:
+            return m

Subsets - Leetcode 78.py

@@ -0,0 +1,20 @@
+class Solution:
+    def subsets(self, nums: List[int]) -> List[List[int]]:
+        n = len(nums)
+        res, sol = [], []
+
+        def backtrack(i):
+            if i == n:
+                res.append(sol[:])
+                return
+
+            # Don't pick nums[i]
+            backtrack(i + 1)
+
+            # Pick nums[i]
+            sol.append(nums[i])
+            backtrack(i + 1)
+            sol.pop()
+
+        backtrack(0)
+        return res

Word Search - Leetcode 79.py

@@ -0,0 +1,37 @@
+class Solution:
+    def exist(self, board: List[List[str]], word: str) -> bool:
+        m = len(board)
+        n = len(board[0])
+        W = len(word)
+
+        if m == 1 and n == 1:
+            return board[0][0] == word
+
+        def backtrack(pos, index):
+            i, j = pos
+
+            if index == W:
+                return True
+
+            if board[i][j] != word[index]:
+                return False
+
+            char = board[i][j]
+            board[i][j] = "#"
+
+            for i_off, j_off in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
+                r, c = i + i_off, j + j_off
+
+                if 0 <= r < m and 0 <= c < n:
+                    if backtrack((r, c), index + 1):
+                        return True
+
+            board[i][j] = char
+            return False
+
+        for i in range(m):
+            for j in range(n):
+                if backtrack((i, j), 0):
+                    return True
+
+        return False