diff --git a/3sum/seungseung88.js b/3sum/seungseung88.js
new file mode 100644
index 0000000000..a3eeaafc4e
--- /dev/null
+++ b/3sum/seungseung88.js
@@ -0,0 +1,35 @@
+/**
+ *
+ * 시간 복잡도: O(n log n) + O(n^2) => O(n^2)
+ * 공간 복잡도: O(1)
+ * - 자바스크립트 배열은 원래의 배열 자체를 바꿈
+ */
+const threeSum = (numbers) => {
+  let result = [];
+  numbers.sort((a, b) => a - b);
+
+  for (let i = 0; i < numbers.length; i += 1) {
+    if (i > 0 && numbers[i] === numbers[i - 1]) continue;
+
+    let l = i + 1;
+    let r = numbers.length - 1;
+
+    while (l < r) {
+      const threeSum = numbers[i] + numbers[l] + numbers[r];
+
+      if (threeSum > 0) {
+        r -= 1;
+      } else if (threeSum < 0) {
+        l += 1;
+      } else {
+        result.push([numbers[i], numbers[l], numbers[r]]);
+        while (l < r && numbers[l] === numbers[l + 1]) l += 1;
+        while (l < r && numbers[r] === numbers[r - 1]) r -= 1;
+        l += 1;
+        r -= 1;
+      }
+    }
+  }
+
+  return result;
+};
diff --git a/climbing-stairs/seungseung88.js b/climbing-stairs/seungseung88.js
new file mode 100644
index 0000000000..3e7a573668
--- /dev/null
+++ b/climbing-stairs/seungseung88.js
@@ -0,0 +1,33 @@
+/**
+ * 시간복잡도: O(n)
+ *  - for문 O(n)
+ * 공간복잡도: O(n)
+ *  - arr O(n)
+ */
+// const climbStairs = (n) => {
+//   const arr = [1, 2];
+
+//   for (let i = 2; i < n; i += 1) {
+//     arr[i] = arr[i - 1] + arr[i - 2];
+//   }
+
+//   return arr[n - 1];
+// };
+
+/**
+ * 시간복잡도: O(n)
+ *  - for문 O(n)
+ * 공간복잡도: O(1)
+ */
+const climbStairs = (n) => {
+  let one = 1;
+  let two = 1;
+
+  for (let i = 0; i <= n - 2; i += 1) {
+    let temp = one + two;
+    one = two;
+    two = temp;
+  }
+
+  return two;
+};
diff --git a/product-of-array-except-self/seungseung88.js b/product-of-array-except-self/seungseung88.js
new file mode 100644
index 0000000000..343bfd263c
--- /dev/null
+++ b/product-of-array-except-self/seungseung88.js
@@ -0,0 +1,63 @@
+/**
+ * 시간복잡도: O(n)
+ *  - 첫번째 for문 O(n)
+ *  - 두번째 for문 O(n)
+ *
+ * 공간 복잡도: O(1)
+ *  - 추가 배열 생성 X
+ */
+// const productExceptSelf = (nums) => {
+//   let multiplyResult = 1;
+//   let countZero = 0;
+
+//   for (let i = 0; i < nums.length; i += 1) {
+//     if (nums[i] === 0) {
+//       countZero += 1;
+
+//       if (countZero >= 2) {
+//         multiplyResult = 0;
+//         break;
+//       }
+
+//       continue;
+//     }
+//     multiplyResult *= nums[i];
+//   }
+
+//   for (let i = 0; i < nums.length; i += 1) {
+//     if (countZero === 1) {
+//       if (nums[i] === 0) {
+//         nums[i] = multiplyResult;
+//       } else {
+//         nums[i] = 0;
+//       }
+//     } else if (countZero >= 2) {
+//       nums[i] = 0;
+//     } else {
+//       nums[i] = multiplyResult / nums[i];
+//     }
+//   }
+
+//   return nums;
+// };
+
+// 누적 합 이용
+const productExceptSelf = (nums) => {
+  const result = Array(nums.length).fill(1);
+
+  let prefix = 1;
+
+  for (let i = 0; i < nums.length; i += 1) {
+    result[i] = prefix;
+    prefix *= nums[i];
+  }
+
+  let postfix = 1;
+
+  for (let i = nums.length - 1; i >= 0; i -= 1) {
+    result[i] *= postfix;
+    postfix *= nums[i];
+  }
+
+  return result;
+};
diff --git a/valid-anagram/seungseung88.js b/valid-anagram/seungseung88.js
new file mode 100644
index 0000000000..165cc5af1d
--- /dev/null
+++ b/valid-anagram/seungseung88.js
@@ -0,0 +1,24 @@
+/**
+ * 시간복잡도: O(n)
+ *  - 첫번째 for문 O(n)
+ *  - 두번째 for문 최대 O(n)
+ * 공간복잡도: O(n)
+ *  - count O(n)
+ */
+
+const isAnagram = (s, t) => {
+  if (s.length !== t.length) return false;
+
+  const count = {};
+
+  for (let i = 0; i < s.length; i += 1) {
+    count[s[i]] = (count[s[i]] || 0) + 1;
+    count[t[i]] = (count[t[i]] || 0) - 1;
+  }
+
+  for (const i of Object.values(count)) {
+    if (i !== 0) return false;
+  }
+
+  return true;
+};
diff --git a/validate-binary-search-tree/seungseung88.js b/validate-binary-search-tree/seungseung88.js
new file mode 100644
index 0000000000..f44a826307
--- /dev/null
+++ b/validate-binary-search-tree/seungseung88.js
@@ -0,0 +1,20 @@
+/**
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+var isValidBST = function (root) {
+  let prev = -Infinity;
+
+  const inorder = (node) => {
+    if (!node) return true;
+
+    if (!inorder(node.left)) return false;
+
+    if (node.val <= prev) return false;
+    prev = node.val;
+
+    return inorder(node.right);
+  };
+
+  return inorder(root);
+};