Merge pull request #1468 from hsskey/main

[hsskey] Week 07 Solutions

Author: hsskey

longest-substring-without-repeating-characters/hsskey.js

@@ -0,0 +1,20 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var lengthOfLongestSubstring = function(s) {
+    const charSet = new Set();
+    let l = 0;
+    let res = 0;
+
+    for (let r = 0; r < s.length; r++) {
+        while (charSet.has(s[r])) {
+            charSet.delete(s[l]);
+            l += 1;
+        }
+        charSet.add(s[r]);
+        res = Math.max(res, r - l + 1);
+    }
+
+    return res;
+};

number-of-islands/hsskey.js

@@ -0,0 +1,56 @@
+/**
+ * @param {character[][]} grid
+ * @return {number}
+ */
+var numIslands = function(grid) {
+    if (!grid.length) return 0;
+
+    const rows = grid.length;
+    const cols = grid[0].length;
+    const visit = new Set();
+    let islands = 0;
+
+    const bfs = (r, c) => {
+        const queue = [];
+        queue.push([r, c]);
+        visit.add(`${r},${c}`);
+
+        while (queue.length) {
+            const [row, col] = queue.shift();
+            const directions = [
+                [1, 0],
+                [-1, 0],
+                [0, 1],
+                [0, -1],
+            ];
+
+            for (const [dr, dc] of directions) {
+                const newRow = row + dr;
+                const newCol = col + dc;
+
+                if (
+                    newRow >= 0 &&
+                    newRow < rows &&
+                    newCol >= 0 &&
+                    newCol < cols &&
+                    grid[newRow][newCol] === '1' &&
+                    !visit.has(`${newRow},${newCol}`)
+                ) {
+                    queue.push([newRow, newCol]);
+                    visit.add(`${newRow},${newCol}`);
+                }
+            }
+        }
+    };
+
+    for (let r = 0; r < rows; r++) {
+        for (let c = 0; c < cols; c++) {
+            if (grid[r][c] === '1' && !visit.has(`${r},${c}`)) {
+                bfs(r, c);
+                islands += 1;
+            }
+        }
+    }
+
+    return islands;
+};

reverse-linked-list/hsskey.js

@@ -0,0 +1,25 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var reverseList = function(head) {
+    if (head === null) return null;
+
+    let newHead = head;
+    if (head.next !== null) {
+        newHead = reverseList(head.next);
+
+        head.next.next = head;
+    }
+
+    head.next = null;
+
+    return newHead;
+};

set-matrix-zeroes/hsskey.js

@@ -0,0 +1,42 @@
+const setZeroes = (matrix) => {
+    const ROWS = matrix.length;
+    const COLS = matrix[0].length;
+    let rowZero = false;
+
+    // 1. 어떤 행과 열이 0이 되어야 하는지 기록
+    for (let r = 0; r < ROWS; r++) {
+        for (let c = 0; c < COLS; c++) {
+            if (matrix[r][c] === 0) {
+                matrix[0][c] = 0;
+                if (r > 0) {
+                    matrix[r][0] = 0;
+                } else {
+                    rowZero = true;
+                }
+            }
+        }
+    }
+
+    // 2. 첫 번째 행과 첫 번째 열을 제외한 나머지 처리
+    for (let r = 1; r < ROWS; r++) {
+        for (let c = 1; c < COLS; c++) {
+            if (matrix[0][c] === 0 || matrix[r][0] === 0) {
+                matrix[r][c] = 0;
+            }
+        }
+    }
+
+    // 3. 첫 번째 열 처리
+    if (matrix[0][0] === 0) {
+        for (let r = 0; r < ROWS; r++) {
+            matrix[r][0] = 0;
+        }
+    }
+
+    // 4. 첫 번째 행 처리
+    if (rowZero) {
+        for (let c = 0; c < COLS; c++) {
+            matrix[0][c] = 0;
+        }
+    }
+};

unique-paths/hsskey.js

@@ -0,0 +1,20 @@
+/**
+ * @param {number} m
+ * @param {number} n
+ * @return {number}
+ */
+var uniquePaths = function(m, n) {
+    let row = new Array(n).fill(1);
+
+    for (let i = 0; i < m - 1; i++) {
+        const newRow = new Array(n).fill(1);
+
+        for (let j = n - 2; j >= 0; j--) {
+            newRow[j] = newRow[j + 1] + row[j];
+        }
+
+        row = newRow;
+    }
+
+    return row[0];
+};