[ppxyn1] WEEK 07 solutions

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

@@ -0,0 +1,15 @@
+#idea : - 
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        charSet = set()
+        left = 0
+        res = 0
+        for right in range(len(s)):
+            while s[right] in charSet:
+                charSet.remove(s[left])
+                left += 1
+            charSet.add(s[right])
+            res =  max(res, right-left+1)
+        return res
+
+

number-of-islands/ppxyn1.py

@@ -0,0 +1,38 @@
+#idea : bfs
+from collections import deque
+
+class Solution:
+    def numIslands(self, grid: List[List[str]]) -> int:
+        if not grid:
+            return 0
+
+        rows, cols = len(grid), len(grid[0])
+        visited = set()
+        islands = 0
+
+        def bfs(r, c):
+            q = deque()
+            visited.add((r, c))
+            q.append((r, c))
+
+            directions = [(1,0), (-1,0), (0,1), (0,-1)]
+
+            while q:
+                row, col = q.popleft()
+                for x, y in directions:
+                    nr, nc = row + x, col + y
+
+                    if 0 <= nr < rows and 0 <= nc < cols:
+                        if grid[nr][nc] == "1" and (nr, nc) not in visited:
+                            visited.add((nr, nc))
+                            q.append((nr, nc))
+
+        for r in range(rows):
+            for c in range(cols):
+                if grid[r][c] == "1" and (r, c) not in visited:
+                    bfs(r, c)
+                    islands += 1
+
+        return islands
+
+

unique-paths/ppxyn1.py

@@ -0,0 +1,22 @@
+# idea : - 
+class Solution:
+    def uniquePaths(self, m: int, n: int) -> int:
+        dp = []
+        for _ in range(m):
+            dp.append([0]*n)
+        dp[0][0] = 1
+
+        for i in range(m):
+            for j in range(n):
+                if i == j == 0:
+                    continue
+                val = 0
+                if i > 0:
+                    val += dp[i-1][j]
+                if j > 0:
+                    val += dp[i][j-1]
+                dp[i][j] = val
+        return dp[m-1][n-1]
+
+
+