diff --git a/top-100-liked/1-two-sum/two-sum.md b/top-100-liked/1-two-sum/two-sum.md
new file mode 100644
index 0000000..b902ff3
--- /dev/null
+++ b/top-100-liked/1-two-sum/two-sum.md
@@ -0,0 +1,40 @@
+# 1. Two Sum
+
+<br>
+
+Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.
+
+You may assume that each input would have exactly one solution, and you may not use the same element twice.
+
+You can return the answer in any order.
+
+<br>
+
+Example 1:
+
+Input: nums = [2,7,11,15], target = 9 <br>
+Output: [0,1] <br>
+Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].
+
+Example 2:
+
+Input: nums = [3,2,4], target = 6 <br>
+Output: [1,2]
+
+Example 3:
+
+Input: nums = [3,3], target = 6 <br>
+Output: [0,1]
+
+<br>
+
+Constraints:
+
+- 2 <= nums.length <= 104
+- 109 <= nums[i] <= 109
+- 109 <= target <= 109
+- Only one valid answer exists.
+
+<br>
+
+Follow-up: Can you come up with an algorithm that is less than O(n2) time complexity?
\ No newline at end of file
diff --git a/top-100-liked/1-two-sum/twoSum.js b/top-100-liked/1-two-sum/twoSum.js
new file mode 100644
index 0000000..f9aa317
--- /dev/null
+++ b/top-100-liked/1-two-sum/twoSum.js
@@ -0,0 +1,21 @@
+// Method 1: 0(n2) time complexity
+const findTwoSum = (nums, target) => {
+  for (let i = 0; i < nums.length - 1; i++) {
+    for (let j = i + 1; j < nums.length; j++) {
+      if (nums[i] + nums[j] === target) return [i, j];
+    }
+  }
+};
+
+
+// Method 2: less than 0(n2) time complexity
+const twoSum = (nums, target) => {
+  const map = new Map();
+
+  for (let i = 0; i < nums.length; i++) {
+    const difference = target - nums[i];
+
+    if (map.has(difference)) return [map.get(difference), i];
+    map.set(nums[i], i);
+  }
+};
\ No newline at end of file