diff --git a/contains-duplicate/jaejeong1.java b/contains-duplicate/jaejeong1.java
new file mode 100644
index 000000000..0b129ad1e
--- /dev/null
+++ b/contains-duplicate/jaejeong1.java
@@ -0,0 +1,16 @@
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+class SolutionJaeJeong1 {
+  public boolean containsDuplicate(int[] nums) {
+    // 해시맵 사용해서 같은 값의 카운트가 1보다 크면 true 반환
+    // 끝까지 다 돌면 false 반환
+    // 또는 해시셋 사용해서 모두 해시셋에 넣고
+    // 길이 비교해서 같으면 false, 다르면 true 반환
+    // 시간복잡도: O(N), 공간복잡도: O(N)
+
+    Set<Integer> set = Arrays.stream(nums).collect(HashSet::new, Set::add, Set::addAll);
+    return set.size() != nums.length;
+  }
+}
diff --git a/kth-smallest-element-in-a-bst/jaejeong1.java b/kth-smallest-element-in-a-bst/jaejeong1.java
new file mode 100644
index 000000000..93217c1c2
--- /dev/null
+++ b/kth-smallest-element-in-a-bst/jaejeong1.java
@@ -0,0 +1,36 @@
+import java.util.ArrayList;
+import java.util.List;
+
+// Definition for a binary tree node.
+class TreeNode {
+     int val;
+     TreeNode left;
+     TreeNode right;
+     TreeNode() {}
+     TreeNode(int val) { this.val = val; }
+     TreeNode(int val, TreeNode left, TreeNode right) {
+         this.val = val;
+         this.left = left;
+         this.right = right;
+     }
+ }
+class SolutionKthSmallest {
+  public int kthSmallest(TreeNode root, int k) {
+    // 이진 검색 트리의 루트와 정수 k가 주어지면 트리에 있는 모든 노드 값 중 k번째로 작은 값(1-인덱스)을 반환합니다.
+    // 이진 검색 트리의 특성을 이용해 중위 순회를 하면 노드 값이 오름차순으로 정렬된다.
+    // 정렬 후 k번째 값을 반환한다.
+    // 시간복잡도: O(N), 공간복잡도: O(N)
+    List<Integer> list = new ArrayList<>();
+    inorder(root, list);
+    return list.get(k - 1);
+  }
+
+  private void inorder(TreeNode root, List<Integer> list) {
+    if (root == null) {
+      return;
+    }
+    inorder(root.left, list);
+    list.add(root.val);
+    inorder(root.right, list);
+  }
+}
diff --git a/number-of-1-bits/jaejeong1.java b/number-of-1-bits/jaejeong1.java
new file mode 100644
index 000000000..d85a7e63e
--- /dev/null
+++ b/number-of-1-bits/jaejeong1.java
@@ -0,0 +1,14 @@
+class SolutionJaejeong1 {
+  public int hammingWeight(int n) {
+    // 주어진 양의 정수를 이진수로 변환하고, 1로 설정된 자릿수의 개수를 반환
+    // 시간복잡도: O(1), 공간복잡도: O(1)
+    int num = 0;
+    for (int i=0; i<32; i++) {
+      if((n & 1) == 1) {
+        num++;
+      }
+      n = n >> 1;
+    }
+    return num;
+  }
+}
diff --git a/palindromic-substrings/jaejeong1.java b/palindromic-substrings/jaejeong1.java
new file mode 100644
index 000000000..e5baf2d35
--- /dev/null
+++ b/palindromic-substrings/jaejeong1.java
@@ -0,0 +1,52 @@
+class SolutionPalindromicSubstrings {
+  // 1번쨰 풀이: 구현해야할 로직을 팰린드롬 여부 검사와 검사할 대상 문자열을 구하는 로직 둘로 나눈다
+  // 팰린드롬 여부 검사: 투포인터 사용, lt=0, rt=length-1 로 시작해 동등성 여부를 검사
+  // 시간복잡도: O(N), 공간복잡도: O(1)
+  // 대상 문자열 구하기: 투포인터 사용. rt가 length보다 같거나 작을떄까지 계속 증가시키고,
+  // rt가 끝에 도달하면 lt를 증가시키고, rt를 lt+1로 만든다. 모든 과정에서 팰린드롬 여부를 검사한다
+  // 시간복잡도: O(N), 공간복잡도: O(1)
+  // 결과
+  // 시간복잡도: O(N^2), 공간복잡도: O(1)
+
+  public int countSubstrings(String s) {
+    var subStrings = s.toCharArray();
+
+    if (subStrings.length == 0) return 0;
+    if (subStrings.length == 1) return 1;
+
+    var answer = 0;
+
+    var lt = 0;
+    var rt = 1;
+    while(lt < subStrings.length){
+      if (isPalindrome(s.substring(lt, rt))) {
+        answer++;
+      }
+
+      if (rt <= subStrings.length-1){
+        rt++;
+      } else {
+        lt++;
+        rt = lt+1;
+      }
+    }
+
+    return answer;
+  }
+
+  private boolean isPalindrome(String s) {
+    var chars = s.toCharArray();
+    var lt = 0;
+    var rt = chars.length - 1;
+
+    while(lt < rt) {
+      if (chars[lt] != chars[rt]) {
+        return false;
+      }
+      lt++;
+      rt--;
+    }
+
+    return true;
+  }
+}
diff --git a/top-k-frequent-elements/jaejeong1.java b/top-k-frequent-elements/jaejeong1.java
new file mode 100644
index 000000000..2d8abe76a
--- /dev/null
+++ b/top-k-frequent-elements/jaejeong1.java
@@ -0,0 +1,24 @@
+import java.util.HashMap;
+import java.util.Map;
+
+class SolutionTopKFrequentElements {
+  public int[] topKFrequent(int[] nums, int k) {
+    // 빈도순으로 k개 반환
+    // 빈도 체크: 해시맵으로 카운트. 시간복잡도 O(N), 공간복잡도 O(N)
+    // 빈도순 정렬: sorting, 시간복잡도 O(N log N), 공간복잡도 O(N)
+    // 합산: 시간복잡도 O(N log N), 공간복잡도 O(N)
+
+    // 빈도 체크
+    Map<Integer, Integer> freq = new HashMap<>();
+    for (int num : nums) {
+      freq.put(num, freq.getOrDefault(num, 0) + 1);
+    }
+
+    // 빈도순 정렬
+    return freq.keySet().stream()
+      .sorted((a, b) -> freq.get(b) - freq.get(a))
+      .mapToInt(i -> i)
+      .limit(k) // 배열에서 상위 k개만 반환
+      .toArray();
+  }
+}