diff --git a/contains-duplicate/hyogshin.py b/contains-duplicate/hyogshin.py
new file mode 100644
index 000000000..84f95c69b
--- /dev/null
+++ b/contains-duplicate/hyogshin.py
@@ -0,0 +1,17 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        if len(nums) == len(set(nums)):
+            return False
+        else:
+            return True
+
+
+
+'''
+시간 복잡도: O(n)
+- set(nums)는 내부적으로 nums의 모든 원소에 대해 __hash__() 및 __eq__() 호출 -> O(n)
+- len() 함수는 O(1) -> 무시
+
+공간 복잡도: O(n)
+- set(nums)는 nums의 원소를 모두 저장할 수 있게 공간 사용 -> 최악의 경우 O(n)
+'''
diff --git a/house-robber/hyogshin.py b/house-robber/hyogshin.py
new file mode 100644
index 000000000..c1be83a34
--- /dev/null
+++ b/house-robber/hyogshin.py
@@ -0,0 +1,25 @@
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        dp = [0] * (len(nums))
+        dp[0] = nums[0]
+        if len(nums) > 1:
+            dp[1] = max(dp[0], nums[1])
+
+        for i in range(2, len(nums)):
+            dp[i] = max(dp[i-2] + nums[i], dp[i-1])
+        
+        return max(dp)
+
+'''
+시간 복잡도: O(n log n)
+- set() -> O(n)
+- sorted() -> O(n log n)
+- for loop -> O(n)
+- max() -> O(n)
+
+공간 복잡도: O(n)
+- set() -> O(n)
+- sorted list -> O(n)
+- rs -> O(n)
+- O(3n) => O(n)
+'''
diff --git a/longest-consecutive-sequence/hyogshin.py b/longest-consecutive-sequence/hyogshin.py
new file mode 100644
index 000000000..87db1bcab
--- /dev/null
+++ b/longest-consecutive-sequence/hyogshin.py
@@ -0,0 +1,32 @@
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        if not nums:
+            return 0
+        s = set(nums)
+        nums = sorted(list(s))
+        rs = []
+        cnt = 1
+
+        for i in range(len(nums)-1):
+            if (nums[i] + 1) == nums[i+1]:
+                cnt += 1
+            else:
+                rs.append(cnt)
+                cnt = 1
+
+        rs.append(cnt)
+        return max(rs)
+        
+'''
+시간 복잡도: O(n log n)
+- set(nums) -> O(n)
+- sorted(list(s)) -> O(n log n)
+- for loop -> O(n)
+- O(2n) + O(n log n) => O(2n) 이 아니라 왜 O(n log n) 이지?
+
+공간 복잡도: O(n)
+- set -> O(n)
+- sorted() -> O(n)
+- rs -> O(n)
+- O(3n) => O(n)
+'''
diff --git a/top-k-frequent-elements/hyogshin.py b/top-k-frequent-elements/hyogshin.py
new file mode 100644
index 000000000..e4b75722a
--- /dev/null
+++ b/top-k-frequent-elements/hyogshin.py
@@ -0,0 +1,33 @@
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        plus = [0] * (10**4 + 1)
+        minus = [0] * (10**4 + 1)
+
+        for i in range(len(nums)):
+            if nums[i] < 0:
+                minus[-(nums[i])] += 1
+            else:
+                plus[nums[i]] += 1
+
+        ans = []
+        for i in range(k):
+            if max(max(minus), max(plus)) == max(plus):
+                idx = plus.index(max(plus))
+                ans.append(idx)
+                plus[idx] = 0
+            else:
+                idx = minus.index(max(minus))
+                ans.append(-(idx))
+                minus[idx] = 0
+
+        return ans
+
+'''
+시간 복잡도: O(1)
+- for loop -> 보통 O(n) 이지만, 길이 10001 짜리 고정 배열 -> O(1)로 취급 가능
+
+공간 복잡도: 입력 제외 -> O(1), 입력 포함 -> O(n)
+- plus 배열: 10001 -> O(1)
+- minus 배열: 10001 -> O(1)
+- ans 배열: 길이 k -> O(k)
+'''
diff --git a/two-sum/hyogshin.py b/two-sum/hyogshin.py
new file mode 100644
index 000000000..4b9a6ff2a
--- /dev/null
+++ b/two-sum/hyogshin.py
@@ -0,0 +1,23 @@
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        rs = []
+        for i in range(len(nums) - 1, -1, -1):
+            pair = target - nums[i]
+            if pair not in nums or i == nums.index(pair):
+                continue
+            idx = nums.index(pair)
+            if pair in nums:
+                rs.append(i)
+                rs.append(idx)
+                break
+        return rs        
+
+'''
+시간 복잡도: O(n^2)
+- nums.index(pair) -> O(n)
+- for loop 안에서 nums.index(pair) 최대 2번 호출 -> O(2n^2) -> O(n^2)
+
+공간 복잡도: O(1)
+- rs 배열에서 number 2개 저장 -> O(1) 공간
+- nums 복사나 set/dict 없음
+'''