diff --git a/clone-graph/imsosleepy.java b/clone-graph/imsosleepy.java
new file mode 100644
index 000000000..791f57aaf
--- /dev/null
+++ b/clone-graph/imsosleepy.java
@@ -0,0 +1,22 @@
+// 문제 의도를 잘 모르겠음. 깊은 복사가 된 Node를 만들면 된다.
+// DFS로 풀면 되고, BFS도 가능하겠지만 BFS는 까딱 잘못하면 타임아웃이 나서 그냥 DFS로 해결
+class Solution {
+ private Map<Node, Node> visited = new HashMap<>();
+
+ public Node cloneGraph(Node node) {
+ if (node == null) return null;
+
+ if (visited.containsKey(node)) {
+ return visited.get(node);
+ }
+
+ Node cloneNode = new Node(node.val);
+ visited.put(node, cloneNode);
+
+ for (Node neighbor : node.neighbors) {
+ cloneNode.neighbors.add(cloneGraph(neighbor));
+ }
+
+ return cloneNode;
+ }
+}
diff --git a/longest-common-subsequence/imsosleepy.java b/longest-common-subsequence/imsosleepy.java
new file mode 100644
index 000000000..7d3d9de24
--- /dev/null
+++ b/longest-common-subsequence/imsosleepy.java
@@ -0,0 +1,20 @@
+// 공통 부분 수열 문제는 되게 유명한 문제임
+// 일반적인 DP는 O(N)인데, 이건 O(N^2)이라 어려움
+// GPT의 도움을 받았음. 따로 정리가 필요할 듯
+class Solution {
+ public int longestCommonSubsequence(String text1, String text2) {
+ int m = text1.length(), n = text2.length();
+ int[][] dp = new int[m + 1][n + 1];
+
+ for (int i = 1; i <= m; i++) {
+ for (int j = 1; j <= n; j++) {
+ if (text1.charAt(i - 1) == text2.charAt(j - 1)) {
+ dp[i][j] = dp[i - 1][j - 1] + 1;
+ } else {
+ dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+ }
+ }
+ }
+ return dp[m][n];
+ }
+}
diff --git a/longest-repeating-character-replacement/imsosleepy.java b/longest-repeating-character-replacement/imsosleepy.java
new file mode 100644
index 000000000..463b71322
--- /dev/null
+++ b/longest-repeating-character-replacement/imsosleepy.java
@@ -0,0 +1,24 @@
+// 최근 자주 보였던 슬라이딩 윈도우를 이용한 방법
+// 시간 복잡도 : O(N)
+class Solution {
+ public int characterReplacement(String s, int k) {
+ int left = 0, maxLen = 0;
+ int[] count = new int[26];
+ int maxCount = 0;
+
+ for (int right = 0; right < s.length(); right++) {
+ count[s.charAt(right) - 'A']++; // 오른쪽 문자 추가
+ maxCount = Math.max(maxCount, count[s.charAt(right) - 'A']); // 최빈 문자 업데이트
+
+ // 현재 윈도우의 크기 - 최빈 문자 개수 > k라면 윈도우를 축소
+ while ((right - left + 1) - maxCount > k) {
+ count[s.charAt(left) - 'A']--; // 왼쪽 문자 제거
+ left++;
+ }
+
+ maxLen = Math.max(maxLen, right - left + 1); // 최대 길이 업데이트
+ }
+
+ return maxLen;
+ }
+}
diff --git a/number-of-1-bits/imsosleepy.java b/number-of-1-bits/imsosleepy.java
new file mode 100644
index 000000000..1cd46b099
--- /dev/null
+++ b/number-of-1-bits/imsosleepy.java
@@ -0,0 +1,19 @@
+// 가장 먼저 떠오른 방법이지만 권장되지 않는 방법일 것 같음
+// 변환된 이진 문자열을 치환하는 방식은 O(K + logN)이다.
+class Solution {
+ public int hammingWeight(int n) {
+ return Integer.toBinaryString(n).replace("0", "").length();
+ }
+}
+
+// 그냥 비트 연산자로 푸는게 최고인것 같다.
+class Solution {
+ public int hammingWeight(int n) {
+ int count = 0;
+ while (n != 0) {
+ count += (n & 1); // 마지막 숫자가 1인지 확인
+ n >>>= 1; // n을 1칸 오른쪽 이동
+ }
+ return count;
+ }
+}
diff --git a/sum-of-two-integers/imsosleepy.java b/sum-of-two-integers/imsosleepy.java
new file mode 100644
index 000000000..e31b0a7ff
--- /dev/null
+++ b/sum-of-two-integers/imsosleepy.java
@@ -0,0 +1,18 @@
+// 비트 연산자를 이용한 문제가 접하기 어렵긴한데 자주 나오는 것 같다
+class Solution {
+ public int getSum(int a, int b) {
+ while (b != 0) {
+ int carry = (a & b) << 1; // AND 연산 후 왼쪽 쉬프트하여 자리 올림 계산
+ a = a ^ b; // XOR 연산으로 자리 올림 없는 덧셈 수행
+ b = carry; // 자리 올림을 다음 연산에 사용
+ }
+ return a;
+ }
+}
+
+// 이런식으로도 풀리지만 이런 결과는 원하지 않을지 도..
+class Solution {
+ public int getSum(int a, int b) {
+ return Math.addExact(a, b);
+ }
+}