[jeldo3] Week 7

longest-substring-without-repeating-characters/jeldo.py

@@ -0,0 +1,14 @@
+class Solution:
+    # O(n), n = len(s)
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        max_len = 0
+        chars = dict()
+        l = 0
+        for r in range(len(s)):
+            if s[r] not in chars or chars[s[r]] < l:
+                chars[s[r]] = r
+                max_len = max(max_len, r - l + 1)
+            else:
+                l = chars[s[r]] + 1
+                chars[s[r]] = r
+        return max_len

number-of-islands/jeldo.py

@@ -0,0 +1,19 @@
+class Solution:
+    # O(m*n), m = len(grid), n = len(grid[0])
+    def numgrids(self, grid: list[list[str]]) -> int:
+        def dfs(i, j):
+            if not (0 <= i < len(grid) and 0 <= j < len(grid[0])):
+                return
+            if grid[i][j] == "-1" or grid[i][j] == "0":
+                return
+            grid[i][j] = "-1"
+            for d in dirs:
+                dfs(i + d[0], j + d[1])
+        dirs = [(0, 1), (1, 0), (0, -1), (-1, 0)]
+        count = 0
+        for i in range(len(grid)):
+            for j in range(len(grid[0])):
+                if grid[i][j] == "1":
+                    count += 1
+                    dfs(i, j)
+        return count

reverse-linked-list/jeldo.py

@@ -0,0 +1,15 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    # O(n), n = len(nodes)
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        tail = None
+        while head:
+            temp = head.next
+            head.next = tail
+            tail = head
+            head = temp
+        return tail

set-matrix-zeroes/jeldo.py

@@ -0,0 +1,19 @@
+class Solution:
+    # Time: O(m*n), m = len(matrix), len(matrix[0])
+    # Space: O(m+n)
+    def setZeroes(self, matrix: list[list[int]]) -> None:
+        """
+        Do not return anything, modify matrix in-place instead.
+        """
+        row_zeros, col_zeros = set(), set()
+        for i in range(len(matrix)):
+            for j in range(len(matrix[0])):
+                if matrix[i][j] == 0:
+                    row_zeros.add(i)
+                    col_zeros.add(j)
+        for r in row_zeros:
+            for j in range(len(matrix[0])):
+                matrix[r][j] = 0
+        for c in col_zeros:
+            for i in range(len(matrix)):
+                matrix[i][c] = 0

unique-paths/jeldo.py

@@ -0,0 +1,12 @@
+class Solution:
+    # O(m*n)
+    def uniquePaths(self, m: int, n: int) -> int:
+        dp = [[0]*n for _ in range(m)]
+        for i in range(m):
+            dp[i][0] = 1
+        for i in range(n):
+            dp[0][i] = 1
+        for i in range(1, m):
+            for j in range(1, n):
+                dp[i][j] += dp[i-1][j] + dp[i][j-1]
+        return dp[-1][-1]