diff --git a/longest-consecutive-sequence/HC-kang.ts b/longest-consecutive-sequence/HC-kang.ts
new file mode 100644
index 000000000..9d048bfe7
--- /dev/null
+++ b/longest-consecutive-sequence/HC-kang.ts
@@ -0,0 +1,24 @@
+/**
+ * https://leetcode.com/problems/longest-consecutive-sequence/
+ * T.C.: O(n)
+ * S.C.: O(n)
+ */
+function longestConsecutive(nums: number[]): number {
+  const numSet = new Set(nums);
+  let max = 0;
+
+  for (const num of numSet) {
+    if (numSet.has(num - 1)) {
+      continue;
+    }
+
+    let count = 0;
+    while (numSet.has(num + count)) {
+      count++;
+    }
+
+    if (count > max) max = count;
+  }
+
+  return max;
+}
diff --git a/maximum-product-subarray/HC-kang.ts b/maximum-product-subarray/HC-kang.ts
new file mode 100644
index 000000000..312f744ec
--- /dev/null
+++ b/maximum-product-subarray/HC-kang.ts
@@ -0,0 +1,26 @@
+/**
+ * https://leetcode.com/problems/maximum-product-subarray
+ * T.C. O(n)
+ * S.C. O(1)
+ * All numbers are integers, so multiplying two numbers cannot result in a smaller absolute value.
+ * It's important to pay attention to zeros and negative numbers.
+ */
+function maxProduct(nums: number[]): number {
+  if (nums.length === 0) return 0;
+
+  let max = nums[0];
+  let min = nums[0];
+  let result = nums[0];
+
+  for (let i = 1; i < nums.length; i++) {
+    const num = nums[i];
+    if (num < 0) [max, min] = [min, max];
+
+    max = Math.max(num, max * num);
+    min = Math.min(num, min * num);
+
+    result = Math.max(result, max);
+  }
+
+  return result;
+}
diff --git a/missing-number/HC-kang.ts b/missing-number/HC-kang.ts
new file mode 100644
index 000000000..d8e156b9a
--- /dev/null
+++ b/missing-number/HC-kang.ts
@@ -0,0 +1,10 @@
+/**
+ * https://leetcode.com/problems/missing-number/
+ * T.C.: O(n)
+ * S.C.: O(1)
+ */
+function missingNumber(nums: number[]): number {
+  let sum = nums.length; // i for 0 to n-1. So, n is missing.
+  for (let i = 0; i < nums.length; i++) sum = sum + i - nums[i];
+  return sum;
+}
diff --git a/valid-palindrome/HC-kang.ts b/valid-palindrome/HC-kang.ts
new file mode 100644
index 000000000..b6a6d28af
--- /dev/null
+++ b/valid-palindrome/HC-kang.ts
@@ -0,0 +1,25 @@
+/**
+ * https://leetcode.com/problems/valid-palindrome/
+ * T.C.: O(n)
+ * S.C.: O(1)
+ */
+function isPalindrome(s: string): boolean {
+  function isAlNum(char: string): boolean {
+    return /^[a-zA-Z0-9]$/.test(char);
+  }
+
+  let left = 0;
+  let right = s.length - 1;
+  while (left < right) {
+    while (left < right && !isAlNum(s[left])) left++;
+    while (left < right && !isAlNum(s[right])) right--;
+
+    if (s[left].toLowerCase() !== s[right].toLowerCase()) {
+      return false;
+    }
+
+    left++;
+    right--;
+  }
+  return true;
+}
diff --git a/word-search/HC-kang.ts b/word-search/HC-kang.ts
new file mode 100644
index 000000000..22ffb48e7
--- /dev/null
+++ b/word-search/HC-kang.ts
@@ -0,0 +1,57 @@
+/**
+ * https://leetcode.com/problems/word-search
+ * T.C. O(n * m * 4^l)
+ * S.C. O(n * m)
+ */
+function exist(board: string[][], word: string): boolean {
+  const countMap = new Map<string, number>();
+
+  for (let i = 0; i < word.length; i++) {
+    countMap.set(word[i], (countMap.get(word[i]) || 0) + 1);
+  }
+  for (let i = 0; i < board.length * board[0].length; i++) {
+    countMap.set(board[Math.floor(i / board[0].length)][i % board[0].length], 0);
+  }
+
+  if (Array.from(countMap.values()).some((v) => v > 0)) return false;
+
+  let seen = Array.from({ length: board.length }, () =>
+    new Array(board[0].length).fill(false)
+  );
+  const directives = [
+    [0, 1],
+    [0, -1],
+    [1, 0],
+    [-1, 0],
+  ];
+
+  function dfs(h: number, w: number, index: number): boolean {
+    if (w < 0 || w >= board[0].length) return false;
+    if (h < 0 || h >= board.length) return false;
+
+    if (seen[h][w]) return false;
+    if (board[h][w] !== word[index]) return false;
+    if (index === word.length - 1) return true;
+
+    seen[h][w] = true;
+
+    for (let i = 0; i < 4; i++) {
+      const [dh, dw] = directives[i];
+      if (dfs(h + dh, w + dw, index + 1)) {
+        return true;
+      }
+    }
+
+    seen[h][w] = false;
+    return false;
+  }
+
+  for (let i = 0; i < board.length; i++) {
+    for (let j = 0; j < board[0].length; j++) {
+      if (dfs(i, j, 0)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}