diff --git a/maximum-subarray/Jeehay28.js b/maximum-subarray/Jeehay28.js
new file mode 100644
index 000000000..a2ec53675
--- /dev/null
+++ b/maximum-subarray/Jeehay28.js
@@ -0,0 +1,48 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+
+// Dynamic programming
+
+
+// Optimized Solution:
+// Time Complexity: O(n)
+// Space Complexity: O(1)
+
+
+var maxSubArray = function (nums) {
+
+    let currentMax = nums[0];
+    let globalMax = nums[0]
+
+    for (let i = 1; i < nums.length; i++) {
+
+        currentMax = Math.max(currentMax + nums[i], nums[i]);
+        globalMax = Math.max(currentMax, globalMax);
+
+    }
+
+    return globalMax;
+
+};
+
+
+// Time Complexity: O(n)
+// Space Complexity: O(n)
+
+// var maxSubArray = function (nums) {
+
+//     let dp = [nums[0]];
+
+//     for (let i = 1; i < nums.length; i++) {
+
+//         dp[i] = Math.max(dp[i - 1] + nums[i], nums[i])
+
+//     }
+
+//     return Math.max(...dp)
+
+// };
+
+
diff --git a/product-of-array-except-self/Jeehay28.js b/product-of-array-except-self/Jeehay28.js
new file mode 100644
index 000000000..0672ca6d2
--- /dev/null
+++ b/product-of-array-except-self/Jeehay28.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+
+// Time Complexity: O(n)
+// Space Complexity: O(n)
+var productExceptSelf = function (nums) {
+
+    let result = [];
+
+    let left = Array(nums.length).fill(1)
+    let right = Array(nums.length).fill(1)
+
+    for (let i = 1; i < nums.length; i++) {
+
+        left[i] = left[i - 1] * nums[i - 1];
+        right[nums.length - 1 - i] = right[right.length - i] * nums[nums.length - i]
+
+    }
+
+    for (let i = 0; i < nums.length; i++) {
+        result[i] = left[i] * right[i];
+    }
+
+    return result;
+
+
+};
+
diff --git a/reverse-bits/Jeehay28.js b/reverse-bits/Jeehay28.js
new file mode 100644
index 000000000..4e9330264
--- /dev/null
+++ b/reverse-bits/Jeehay28.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number} n - a positive integer
+ * @return {number} - a positive integer
+ */
+
+// Time Complexity: O(1)
+// Space Complexity: O(1)
+
+var reverseBits = function (n) {
+
+    let stack = [];
+    let num = n;
+
+    for (let i = 0; i < 32; i++) {
+
+        stack.push(num % 2);
+        num = Math.floor(num / 2);
+    }
+
+    stack = stack.reverse();
+
+
+    let result = 0;
+
+    for (let i = 0; i < 32; i++) {
+
+        result += stack[i] * Math.pow(2, i);
+
+    }
+
+    return result;
+
+};
+
+
diff --git a/two-sum/Jeehay28.js b/two-sum/Jeehay28.js
new file mode 100644
index 000000000..9b24e9073
--- /dev/null
+++ b/two-sum/Jeehay28.js
@@ -0,0 +1,49 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+
+
+// Time Complexity : O(n)
+// Space Complexity : O(n)
+
+var twoSum = function (nums, target) {
+
+    let map = new Map();
+
+    for (let i = 0; i < nums.length; i++) {
+
+        const temp = target - nums[i];
+
+        if (map.has(temp)) {
+            return [i, map.get(temp)]
+        }
+
+        map.set(nums[i], i);
+    }
+
+    return [];
+}
+
+
+// Time Complexity: O(n^2)
+// Space Complexity: O(1)
+// This solution is straightforward but inefficient for large arrays. For better performance, consider the hashmap approach.
+
+// var twoSum = function (nums, target) {
+
+//     for (let i = 0; i < nums.length; i++) {
+
+//         const loc = nums.indexOf((target - nums[i]), i + 1);
+
+//         if (loc >= 0) {
+//             return [i, loc]
+//         } else {
+//             continue;
+//         }
+
+//     }
+
+// };
+