diff --git a/3sum/HoonDongKang.ts b/3sum/HoonDongKang.ts
new file mode 100644
index 000000000..907ae685b
--- /dev/null
+++ b/3sum/HoonDongKang.ts
@@ -0,0 +1,39 @@
+/**
+ * [Problem]: [15] 3Sum
+ * (https://leetcode.com/problems/3sum/description/)
+ */
+
+function threeSum(nums: number[]): number[][] {
+    //시간 복잡도: O(n^2)
+    //공간 복잡도: O(1)
+    function pointerFunc(nums: number[]): number[][] {
+        const result: number[][] = [];
+        nums.sort((a, b) => a - b);
+
+        for (let i = 0; i < nums.length; i++) {
+            if (i > 0 && nums[i] === nums[i - 1]) continue;
+            let left = i + 1;
+            let right = nums.length - 1;
+
+            while (left < right) {
+                const sum = nums[i] + nums[left] + nums[right];
+                if (sum === 0) {
+                    result.push([nums[i], nums[left], nums[right]]);
+
+                    while (left < right && nums[left] === nums[left + 1]) left++;
+                    while (left < right && nums[right] === nums[right - 1]) right--;
+
+                    left++;
+                    right--;
+                } else if (sum < 0) {
+                    left++;
+                } else {
+                    right--;
+                }
+            }
+        }
+        return result;
+    }
+
+    return pointerFunc(nums);
+}
diff --git a/climbing-stairs/HoonDongKang.ts b/climbing-stairs/HoonDongKang.ts
new file mode 100644
index 000000000..4117c61e8
--- /dev/null
+++ b/climbing-stairs/HoonDongKang.ts
@@ -0,0 +1,44 @@
+/**
+ * [Problem]: [70] Climbing Stairs
+ * (https://leetcode.com/problems/climbing-stairs/description/)
+ */
+
+function climbStairs(n: number): number {
+    // 시간복잡도 O(n)
+    // 공간복잡도 O(n)
+    function dpFunc(n: number): number {
+        if (n <= 0) return 0;
+
+        let dpArr: number[] = new Array(n);
+        dpArr[0] = 1;
+        dpArr[1] = 2;
+
+        for (let i = 2; i < n; i++) {
+            dpArr[i] = dpArr[i - 1] + dpArr[i - 2];
+        }
+
+        return dpArr[n - 1];
+    }
+
+    // 시간복잡도 O(n)
+    // 공간복잡도 O(1)
+    function dpOptimizedFunc(n: number): number {
+        if (n <= 0) return 0;
+        if (n === 1) return 1;
+        if (n === 2) return 2;
+
+        let prev1 = 1;
+        let prev2 = 2;
+
+        for (let i = 3; i < n + 1; i++) {
+            let currentValue = prev1 + prev2;
+
+            prev1 = prev2;
+            prev2 = currentValue;
+        }
+
+        return prev2;
+    }
+
+    return dpOptimizedFunc(n);
+}
diff --git a/top-k-frequent-elements/HoonDongKang.ts b/top-k-frequent-elements/HoonDongKang.ts
new file mode 100644
index 000000000..ed02e8eeb
--- /dev/null
+++ b/top-k-frequent-elements/HoonDongKang.ts
@@ -0,0 +1,22 @@
+/**
+ * [Problem]: [347] Top K Frequent Elements
+ * (https://leetcode.com/problems/top-k-frequent-elements/description/)
+ */
+
+function topKFrequent(nums: number[], k: number): number[] {
+    // 시간복잡도 O(nlogn)
+    // 공간복잡도 O(n)
+    function mapFun(nums: number[], k: number): number[] {
+        const frequentMap = new Map<number, number>();
+
+        for (let i = 0; i < nums.length; i++) {
+            frequentMap.set(nums[i], (frequentMap.get(nums[i]) || 0) + 1);
+        }
+
+        const sorted = Array.from(frequentMap.entries()).sort((a, b) => b[1] - a[1]);
+
+        return sorted.slice(0, k).map(([num]) => num);
+    }
+
+    return mapFun(nums, k);
+}
diff --git a/valid-anagram/HoonDongKang.ts b/valid-anagram/HoonDongKang.ts
new file mode 100644
index 000000000..881d92a55
--- /dev/null
+++ b/valid-anagram/HoonDongKang.ts
@@ -0,0 +1,49 @@
+/**
+ * [Problem]: [242] Valid Anagram
+ * (https://leetcode.com/problems/valid-anagram/description/
+ */
+function isAnagram(s: string, t: string): boolean {
+    // 시간복잡도: O(nlogn)
+    // 공간복잡도: O(n)
+    function sortJoinFunc(s: string, t: string): boolean {
+        return [...s].sort().join() === [...t].sort().join();
+    }
+
+    // 시간복잡도: O(n)
+    // 공간복잡도: O(n)
+    function asciiDiffFunc(s: string, t: string): boolean {
+        if (s.length !== t.length) return false;
+
+        const asciiMap = new Map<string, number>();
+        for (let i = 0; i < s.length; i++) {
+            const sChar = s[i];
+            const tChar = t[i];
+
+            asciiMap.set(sChar, (asciiMap.get(sChar) || 0) + 1);
+            asciiMap.set(tChar, (asciiMap.get(tChar) || 0) - 1);
+        }
+
+        for (const count of asciiMap.values()) {
+            if (count !== 0) return false;
+        }
+
+        return true;
+    }
+
+    // 시간복잡도: O(n)
+    // 공간복잡도: O(1)
+    function arrayFunc(s: string, t: string): boolean {
+        if (s.length !== t.length) return false;
+
+        let alphabetArr: number[] = new Array(26).fill(0);
+
+        for (let i = 0; i < s.length; i++) {
+            alphabetArr[s.charCodeAt(i) - 97]++;
+            alphabetArr[t.charCodeAt(i) - 97]--;
+        }
+
+        return alphabetArr.every((char) => char === 0);
+    }
+
+    return arrayFunc(s, t);
+}
diff --git a/validate-binary-search-tree/HoonDongKang.ts b/validate-binary-search-tree/HoonDongKang.ts
new file mode 100644
index 000000000..95186e4cf
--- /dev/null
+++ b/validate-binary-search-tree/HoonDongKang.ts
@@ -0,0 +1,50 @@
+/**
+ * [Problem]: [98] Validate Binary Search Tree
+ *
+ * (https://leetcode.com/problems/validate-binary-search-tree/description/)
+ */
+
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+
+function isValidBST(root: TreeNode | null): boolean {
+    //시간 복잡도 O(n)
+    //공간 복잡도 O(n)
+    function dfs(node: TreeNode | null, low: number | null, high: number | null) {
+        if (!node) return true;
+        if ((low !== null && node.val <= low) || (high !== null && node.val >= high)) {
+            return false;
+        }
+
+        return dfs(node.left, low, node.val) && dfs(node.right, node.val, high);
+    }
+
+    //시간 복잡도 O(n)
+    //공간 복잡도 O(n)
+    let prev: number | null = null;
+    function inOrder(node: TreeNode | null): boolean {
+        if (!node) return true;
+
+        if (!inOrder(node.left)) return false;
+
+        if (prev !== null && node.val <= prev) return false;
+
+        prev = node.val;
+
+        return inOrder(node.right);
+    }
+
+    // return dfs(root, null, null);
+    return inOrder(root);
+}