diff --git a/combination-sum/Chaedie.py b/combination-sum/Chaedie.py
new file mode 100644
index 000000000..5cf765c6d
--- /dev/null
+++ b/combination-sum/Chaedie.py
@@ -0,0 +1,35 @@
+"""
+Solution:
+    최초 풀이 당시엔 단순히 dfs로 풀었으나 시간 초과로 실패했습니다.
+    이후 풀이 설명을 통해 i 번째 숫자를 넣거나 / 안넣거나 라는 조건으로 i를 늘려가도록 진행하는 백트래킹을 하면 된다는점을 배웠습니다. 
+    이를 통해 불필요한 중복을 줄이고 효율적인 구현이 가능해집니다.
+
+C: len(candidates)
+T: target size
+
+Time: O(C^T) = 라고 설명되어 있는데 솔찍히 잘 모르겠습니다.
+Space: O(T) = 재귀가 가장 깊을 때 [1,1,1,1...] T 만큼이기 때문에 O(T)
+"""
+
+
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        result = []
+        sol = []
+        n = len(candidates)
+
+        def backtrack(i, cur_sum):
+            if cur_sum == target:
+                result.append(sol.copy())
+                return
+            if cur_sum > target or i == n:
+                return
+
+            backtrack(i + 1, cur_sum)
+
+            sol.append(candidates[i])
+            backtrack(i, cur_sum + candidates[i])
+            sol.pop()
+
+        backtrack(0, 0)
+        return result
diff --git a/maximum-subarray/Chaedie.py b/maximum-subarray/Chaedie.py
new file mode 100644
index 000000000..f65a1ebb7
--- /dev/null
+++ b/maximum-subarray/Chaedie.py
@@ -0,0 +1,64 @@
+"""
+Solution1:
+    sliding window 일 것 같지만 구현이 어려워 일단 Brute Force 부터 진행합니다.
+    -> 시간 초과로 실패
+
+Time: O(n^2) =  n(for) * n(for)
+Space: O(n) = cur 배열
+"""
+
+
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+        n = len(nums)
+        max_sum = float(-inf)
+        for i in range(n):
+            cur = []
+            cur_sum = 0
+            for j in range(i, n):
+                cur_sum += nums[j]
+                cur.append(nums[j])
+                max_sum = max(max_sum, cur_sum)
+        return max_sum
+
+
+"""
+Solution2:
+    Sliding Window로 풀 수 있을거라 생각했는데 잘 안되었습니다.
+"""
+
+
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+        n = len(nums)
+        max_sum = float(-inf)
+
+        l = 0
+        window = 0
+        for r in range(n):
+            window += nums[r]
+            max_sum = max(max_sum, window)
+            while max_sum < window:
+                l += 1
+
+        return max_sum
+
+
+"""
+Solution3 - 알고달레: 
+    솔루션을 통해 학습했습니다.
+    이해가 어려워 다시 풀어볼 예정입니다.
+
+Time: O(n)
+Space: O(1)
+"""
+
+
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+        max_sum = nums[0]
+        cur_sum = 0
+        for num in nums:
+            cur_sum = max(cur_sum + num, num)
+            max_sum = max(cur_sum, max_sum)
+        return max_sum
diff --git a/product-of-array-except-self/Chaedie.py b/product-of-array-except-self/Chaedie.py
new file mode 100644
index 000000000..25876217e
--- /dev/null
+++ b/product-of-array-except-self/Chaedie.py
@@ -0,0 +1,65 @@
+"""
+solution 1:
+    왼쪽부터 곱해가는 prefix,
+    오른쪽부터 곱해가는 postfix,
+    2가지의 배열을 만든다.
+
+    nums = [1,2,3,4]
+    prefix = [1,2,6,24]
+    postfix = [24,12,4,1]
+
+    이후 정답 배열 result[i] = prefix[i - 1] * postfix[i + 1] 이 되도록 만든다.
+    0, n-1 번째 인덱스에선 예외처리를 해준다.
+
+Time: O(n) = prefix 계산 O(n) + postfix 계산 O(n) + result 계산 O(n)
+Space: O(n) = prefix 배열 O(n) + postfix 배열 O(n)
+"""
+
+# class Solution:
+#     def productExceptSelf(self, nums: List[int]) -> List[int]:
+#         n = len(nums)
+
+#         prefix = [1 for i in range(n)]
+#         postfix = [1 for i in range(n)]
+
+#         prefix[0] = nums[0]
+#         for i in range(1, n):
+#             prefix[i] = prefix[i-1] * nums[i]
+
+#         postfix[n - 1] = nums[n - 1]
+#         for i in range(n-2, -1, -1):
+#             postfix[i] = postfix[i + 1] * nums[i]
+
+#         result = []
+#         for i in range(n):
+#             pre = prefix[i - 1] if i - 1 >= 0 else 1
+#             post = postfix[i + 1] if i + 1 < n else 1
+#             result.append(pre * post)
+#         return result
+
+"""
+최적화 풀이 
+Solution:
+    prefix, postfix 배열 저장 없이 순회하며 바로 prefix, postfix 를 곱해서 result 배열에 담는다.
+
+Time: O(n) = O(2n)
+Space: O(1)
+"""
+
+
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        n = len(nums)
+        result = [1] * n
+
+        prefix = 1
+        for i in range(n):
+            result[i] *= prefix
+            prefix *= nums[i]
+
+        postfix = 1
+        for i in range(n - 1, -1, -1):
+            result[i] *= postfix
+            postfix *= nums[i]
+
+        return result
diff --git a/reverse-bits/Chaedie.py b/reverse-bits/Chaedie.py
new file mode 100644
index 000000000..8b603198d
--- /dev/null
+++ b/reverse-bits/Chaedie.py
@@ -0,0 +1,50 @@
+"""
+1. 학습은 진행했지만, 스스로 완벽하게 풀지 못했습니다.
+    다음주에 bit 연산으로 다시 풀어볼 예정입니다.
+"""
+
+
+class Solution:
+
+    # 알고달레 풀이 1) Stack
+    def reverseBits(self, n: int) -> int:
+        stack = []
+        while len(stack) < 32:
+            stack.append(n % 2)
+            n //= 2
+
+        result, scale = 0, 1
+        while stack:
+            result += stack.pop() * scale
+            scale *= 2
+        return result
+
+    # 알고달레 풀이 2) bit manipulation
+    def reverseBits(self, n: int) -> int:
+        result = 0
+        print(n)
+        for i in range(32):
+            print(result)
+            result <<= 1
+            result |= n & 1
+            n >>= 1
+        return result
+
+    # NeetCode 풀이
+    def reverseBits(self, n: int) -> int:
+        res = 0
+
+        for i in range(32):
+            bit = (n >> i) & 1
+            res = res | (bit << (31 - i))
+        return res
+
+    # 스스로 풀기
+    # 한번 더 풀 에정입니다.
+    def reverseBits(self, n: int) -> int:
+        result = 0
+        for i in range(32):
+            result = result << 1
+            result = result | (n & 1)
+            n = n >> 1
+        return result
diff --git a/two-sum/Chaedie.py b/two-sum/Chaedie.py
new file mode 100644
index 000000000..f9acf694a
--- /dev/null
+++ b/two-sum/Chaedie.py
@@ -0,0 +1,21 @@
+"""
+Solution:
+    Use a hash map to store numbers and their indices
+    Iterate through the list and check if difference between target and val 
+    return the index list
+
+Time: O(n)
+Space: O(n)
+
+"""
+
+
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        num_map = {}  # num : index
+
+        for i, val in enumerate(nums):
+            diff = target - val
+            if diff in num_map:
+                return [num_map[diff], i]
+            num_map[val] = i