diff --git a/contains-duplicate/jangwonyoon.js b/contains-duplicate/jangwonyoon.js
new file mode 100644
index 000000000..b1414c3ff
--- /dev/null
+++ b/contains-duplicate/jangwonyoon.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function(nums) {
+    const sortedNums = nums.sort((a, b) => a - b);
+    const length = sortedNums.length - 1;
+
+    for (let i = 0; i < length; i++) {
+        const left = nums[i];
+        const right = nums[i + 1];
+
+        if (left === right) {
+            return true;
+        }
+    }
+
+    return false;
+};
diff --git a/longest-consecutive-sequence/jangwonyoon.js b/longest-consecutive-sequence/jangwonyoon.js
new file mode 100644
index 000000000..1ddb29a87
--- /dev/null
+++ b/longest-consecutive-sequence/jangwonyoon.js
@@ -0,0 +1,60 @@
+/**
+ * solve 1
+ *
+ * 시간 복잡도: O(n log n)
+ * 공간 복잡도: O(n)
+ *
+ * @param {number[]} nums
+ * @return {number}
+ */
+var longestConsecutive = function(nums) {
+    // 예외
+    if (nums.length === 0) {
+        return 0;
+    }
+
+    const sortedArr = [...new Set(nums)].sort((a, b) => a - b);
+
+    let result = 1;
+    let consecutive = 1;
+
+    for (let i = 0; i < sortedArr.length - 1; i++) {
+        const curr = sortedArr[i];
+        const next = sortedArr[i + 1];
+
+        if (next === curr + 1) {
+            consecutive += 1;
+        } else {
+            consecutive = 1;
+        }
+
+        result = Math.max(result, consecutive);
+    }
+
+    return result;
+};
+
+/**
+ * solve 2
+ *
+ * 시간 복잡도: O(n)
+ * 공간 복잡도: O(n)
+ *
+ * @param {number[]} nums
+ * @return {number}
+ */
+var longestConsecutive = function(nums) {
+    let longest = 0;
+    const numSet = new Set(nums);
+
+    for (const num of numSet) {
+        if (numSet.has(num - 1)) continue;
+        let length = 1;
+
+        while (numSet.has(num + length)) length++;
+
+        longest = Math.max(length, longest);
+    }
+
+    return longest;
+}
diff --git a/top-k-frequent-elements/jangwonyoon.js b/top-k-frequent-elements/jangwonyoon.js
new file mode 100644
index 000000000..c41f81795
--- /dev/null
+++ b/top-k-frequent-elements/jangwonyoon.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+
+/*
+ * 시간 복잡도: O(n log n)
+ * 공간 복잡도: O(n)
+ *
+ * 1. map 구조를 사용해서 몇번 나왔는지 카운트한다.
+ * 2. map 구조에서 가장 큰 수를 구한다.
+*/
+var topKFrequent = function(nums, k) {
+    const map = new Map();
+
+    for (let i = 0; i < nums.length; i++) {
+        if (!map.has(nums[i])) {
+            map.set(nums[i], 1);
+        } else {
+            map.set(nums[i], map.get(nums[i]) + 1);
+        }
+    }
+
+    const result = [...map.entries()].sort((a, b) => b[1] - a[1]);
+
+    return result.slice(0, k).map((val) => val[0]);
+};
diff --git a/two-sum/jangwonyoon.js b/two-sum/jangwonyoon.js
new file mode 100644
index 000000000..7e7c57d31
--- /dev/null
+++ b/two-sum/jangwonyoon.js
@@ -0,0 +1,50 @@
+/**
+ * solve 1
+ *
+ * 시간 복잡도: O(n^2)
+ * 공간 복잡도: O(1)
+ *
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function(nums, target) {
+    const length = nums.length - 1;
+
+    for (let i = 0; i < length; i++) {
+        for(let j = length; j > 0; j--) {
+            const sum = nums[i] + nums[j];
+
+            if (i !== j) {
+                if (sum === target) {
+                    return [i , j];
+                }
+            }
+        }
+    }
+};
+
+
+/**
+ * solve 2
+ *
+ * 시간 복잡도: O(n)
+ * 공간 복잡도: O(n)
+ *
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function(nums, target) {
+    const map = new Map();
+
+    for (let i = 0; i < nums.length; i++) {
+        const temp = target - nums[i];
+
+        if (map.has(temp)) {
+            return [map.get(temp), i];
+        }
+
+        map.set(nums[i], i);
+    }
+};