Solutions week 07

Author: hoyeongkwak

longest-substring-without-repeating-characters/hoyeongkwak.ts

@@ -0,0 +1,33 @@
+/*
+    abc a l = 3
+    bca b l = 3
+    cab c l = 3
+    abc b l = 1
+    cb
+
+    pw w l = 2
+    wke w l = 3
+    w
+*/
+/*
+    time complexity : O(n)
+    space complexity : O(n)
+*/
+function lengthOfLongestSubstring(s: string): number {
+    if (s.length === 0) return 0
+
+    let maxLen = 0
+    let start = 0
+    const charMap = new Map<string, number>()
+
+    for (let end = 0; end < s.length; end++) {
+        const currChar = s[end]
+
+        if (charMap.has(currChar) && charMap.get(currChar)! >= start) {
+            start = charMap.get(currChar)! + 1
+        }
+        charMap.set(currChar, end)
+        maxLen = Math.max(maxLen, end - start + 1)
+    }
+    return maxLen
+};

number-of-islands/hoyeongkwak.ts

@@ -0,0 +1,32 @@
+/*
+    time complexity : O(m * n)
+    space complexity : O(m)
+*/
+function numIslands(grid: string[][]): number {
+    const rows = grid.length
+    const cols = grid[0].length
+    const direction = [[1, 0], [-1, 0], [0, 1], [0, -1]]
+    let islands = 0
+    for (let r = 0; r < rows; r++) {
+        for (let c = 0; c < cols; c++) {
+            if (grid[r][c] === '1') {
+                islands += 1
+                const queue = new Array()
+
+                grid[r][c] = '0'
+                queue.push([r, c])
+                while (queue.length > 0) {
+                    let curr = queue.shift()
+                    for (const dir of direction) {
+                        let dr = curr[0] + dir[0]
+                        let dc = curr[1] + dir[1]
+                        if (dr < 0 || dr >= rows || dc < 0 || dc >= cols || grid[dr][dc] === '0') continue
+                        grid[dr][dc] = '0'
+                        queue.push([dr, dc])
+                    }
+                }
+            }
+        }
+    }
+    return islands
+};

reverse-linked-list/hoyeongkwak.ts

@@ -0,0 +1,36 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+
+/*
+curr                prev
+1, 2, 3, 4, 5       null
+2, 3, 4, 5          1
+3, 4, 5             2, 1
+4, 5                3, 2, 1
+5                   4, 3, 2, 1
+null                5, 4, 3, 2, 1
+*/
+/*
+    time complexity : O(n)
+    space complexity : O(1)
+*/
+function reverseList(head: ListNode | null): ListNode | null {
+    let curr = head
+    let prev = null
+    while (curr) {
+        let next = curr.next
+        curr.next = prev
+        prev = curr
+        curr = next
+    }
+    return prev
+};

set-matrix-zeroes/hoyeongkwak.ts

@@ -0,0 +1,28 @@
+/*
+    (0, 0)  0~m, 0~n 
+    (1, 1) (0~m, 1) (1, 0~n)
+
+    time complexity : O(m * n)
+    space complexity : O(m * n)
+*/
+function setZeroes(matrix: number[][]): void {
+    const rows = matrix.length
+    const cols = matrix[0].length
+    const zeroPosition = []
+    for (let r = 0; r < rows; r++) {
+        for (let c = 0; c < cols; c++) {
+            if (matrix[r][c] === 0) {
+                zeroPosition.push([r,c])
+            }
+        }
+    }
+    
+    for (let m = 0; m < zeroPosition.length; m++) {
+        const r = zeroPosition[m][0]
+        const c = zeroPosition[m][1]
+        matrix[r].fill(0)
+        for (let i = 0; i < rows; i++) {
+            matrix[i][c] = 0
+        }
+    }
+};

unique-paths/hoyeongkwak.ts

@@ -0,0 +1,14 @@
+/*
+    time complexity : O(m * n)
+    space complexity : O(m * n)
+*/
+function uniquePaths(m: number, n: number): number {
+    const dp = Array.from({ length: m }, () => Array(n).fill(1)) 
+    let results = 0
+    for (let r = 1; r < m; r++) {
+        for (let c = 1; c < n; c++) {  
+            dp[r][c] = dp[r - 1][c] + dp[r][c - 1]
+        }
+    }
+    return dp[m-1][n-1]
+};