diff --git a/contains-duplicate/Jeehay28.js b/contains-duplicate/Jeehay28.js
new file mode 100644
index 000000000..fcfb8589d
--- /dev/null
+++ b/contains-duplicate/Jeehay28.js
@@ -0,0 +1,7 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function (nums) {
+  return nums.length !== new Set(nums).size;
+};
diff --git a/house-robber/Jeehay28.js b/house-robber/Jeehay28.js
new file mode 100644
index 000000000..6fc9d239c
--- /dev/null
+++ b/house-robber/Jeehay28.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+
+//  Bottom-Up DP (with constant space) 방식 
+
+// 시간 복잡도 (Time Complexity)
+// O(n) — 입력 배열의 크기에 비례하여 수행 시간이 증가
+
+// 공간 복잡도 (Space Complexity)
+// O(1) — 입력 크기에 관계없이 사용하는 메모리 공간이 일정
+
+
+var rob = function (nums) {
+
+    if (nums.length === 1) {
+        return nums[0];
+    }
+
+    let robbed_2 = nums[0];
+    let robbed_1 = Math.max(nums[0], nums[1]);
+
+    for (let i = 2; i < nums.length; i++) {
+
+        const temp = robbed_1;
+
+        robbed_1 = Math.max(robbed_1, robbed_2 + nums[i]);
+
+        robbed_2 = temp;
+
+    }
+
+    return robbed_1;
+
+};
diff --git a/longest-consecutive-sequence/Jeehay28.js b/longest-consecutive-sequence/Jeehay28.js
new file mode 100644
index 000000000..f1f92ecf4
--- /dev/null
+++ b/longest-consecutive-sequence/Jeehay28.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var longestConsecutive = function (nums) {
+  let result = [];
+  let longest = [];
+
+  numsSorted = nums.sort((a, b) => a - b);
+
+  numsFiltered = [...new Set(numsSorted)];
+
+  for (let i = 0; i < numsFiltered.length; i++) {
+    if (result.length === 0) {
+      result.push(numsFiltered[i]);
+    } else if (result.length >= 1) {
+      if (numsFiltered[i] === result[result.length - 1] + 1) {
+        result.push(numsFiltered[i]);
+      } else {
+        longest.push(result.length);
+        result = [numsFiltered[i]];
+      }
+    }
+  }
+
+  if (longest.length === 0) {
+    return result.length;
+  } else {
+    return Math.max(Math.max(...longest), result.length);
+  }
+};
diff --git a/top-k-frequent-elements/Jeehay28.js b/top-k-frequent-elements/Jeehay28.js
new file mode 100644
index 000000000..b127890ef
--- /dev/null
+++ b/top-k-frequent-elements/Jeehay28.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+var topKFrequent = function (nums, k) {
+  let result = [];
+
+  const obj = nums.reduce((acc, cur) => {
+    acc[cur] = (acc[cur] || 0) + 1;
+    return acc;
+  }, {});
+
+  const frequentValues = Object.values(obj)
+    .sort((a, b) => b - a)
+    .slice(0, k);
+
+  for (const [key, value] of Object.entries(obj)) {
+    if (frequentValues.includes(value)) {
+      result.push(parseInt(key));
+    }
+  }
+
+  return result;
+};
diff --git a/valid-palindrome/Jeehay28.js b/valid-palindrome/Jeehay28.js
new file mode 100644
index 000000000..3652e8a5f
--- /dev/null
+++ b/valid-palindrome/Jeehay28.js
@@ -0,0 +1,17 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isPalindrome = function (s) {
+  const reg = /[a-z0-9]/g;
+  const converted = s.toLowerCase().match(reg);
+
+  if (converted === null) {
+    return true;
+  } else {
+    const forward = converted.join("");
+    const backward = converted.reverse().join("");
+
+    return forward === backward;
+  }
+};