From b4e89bd51bfaac9c16bd8db123f1f8b9e7c23169 Mon Sep 17 00:00:00 2001 From: namucy Date: Thu, 2 Jul 2026 18:53:59 +0900 Subject: [PATCH 1/5] valid palindrome solution --- valid-palindrome/namuuCY.java | 51 +++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 valid-palindrome/namuuCY.java diff --git a/valid-palindrome/namuuCY.java b/valid-palindrome/namuuCY.java new file mode 100644 index 0000000000..2a1e6a64a3 --- /dev/null +++ b/valid-palindrome/namuuCY.java @@ -0,0 +1,51 @@ +// 문제 풀이 흐름 1 +// 먼저, 알파벳이 아닌 글자는 다 쳐내는 작업이 필요 +// 그 다음 알파벳으로만 만들어진 문자열에 대해 팰린드롬 확인 +// 길이 확인 후 +// 맨처음에서부터 중간까지, 대칭 값이 맞는지 확인 + +// n = s의 길이라 할때 +// 시간복잡도 : O(n) +// 공간복잡도 : O(n) - 어쩔수없이 trimming한 문자열은 저장해야하므로 + +// 문제 풀이 흐름 2 + +// 문자열 그대로 팰린드롬 확인 스타트 +// 맨 앞과 뒤의 인덱스에서 시작해서 +// 알파벳이 아닌 다른 문자라면 skip +// 알파벳이라면 비교 + +// n = s의 길이라 할때 +// 시간복잡도 : O(n) +// 공간복잡도 : O(1) + + +class Solution { + public boolean isPalindrome(String s) { + int rightIdx = s.length() - 1; + + for (int leftIdx = 0 ; leftIdx <= rightIdx ; leftIdx ++) { + if (!isValid(s.charAt(leftIdx))) continue; + + // rightIdx 조절 + while (leftIdx <= rightIdx && !isValid(s.charAt(rightIdx))) { + rightIdx--; + } + + if (!isSameChar(s.charAt(leftIdx), s.charAt(rightIdx))) { + return false; + } + rightIdx-- ; + } + + return true; + } + + private boolean isValid(char c) { + return 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || '0' <= c && c <= '9'; + } + + private boolean isSameChar(char a, char b) { + return Character.toLowerCase(a) == Character.toLowerCase(b); + } +} From a699dea7ebd98747929f6e8ea818fb8a0444b219 Mon Sep 17 00:00:00 2001 From: namucy Date: Thu, 2 Jul 2026 19:48:12 +0900 Subject: [PATCH 2/5] maximum subarray solution --- maximum-subarray/namuuCY.java | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 maximum-subarray/namuuCY.java diff --git a/maximum-subarray/namuuCY.java b/maximum-subarray/namuuCY.java new file mode 100644 index 0000000000..2215774a38 --- /dev/null +++ b/maximum-subarray/namuuCY.java @@ -0,0 +1,30 @@ +// 문제 풀이 흐름 +// 맨처음에 생각한 풀이는 +// 누적합을 기준으로, +// 누적합의 오른쪽 최대 - 왼쪽 최소 의 값이 제일 큰걸 구하면 된다고 생각했음. +// 예를 들어서 nums = [-2,1,-3,4,-1,2,1,-5,4] 라면 +// 누적합은 [-2 -1 -4 0 -1 1 2 -3] 이 되는데, 값의 최대는 2에서 -4를 뺸 6이 최대라고 생각했음. +// 그래서 어느 한 좌표(왼쪽)를 순회하면서 +// 이 인덱스의 오른쪽(왼쪽 인덱스 +1 부터 끝까지)의 누적합의 최소를 구하면 된다고 생각했음. +// 이 위를 구하기 위해서 누적합에 대해 세그먼트 트리를 구축해두려고 했음. +// 그러면 세그먼트 트리 만드는데 nlogn + 1중 for 문 * log n 조회니까 최대 nlogn의 시간복잡도로 문제를 풀수있음 / 공간복잡도는 O(n log n)이 될것. + +// 근데 제시된 풀이를 보니까 1차원 DP로 푸는것을 봤음. +// DP[i] = Math.max(nums[i], DP[i - 1] + nums[i]); +// 혹은 = nums[i] + (DP[i - 1] > 0) ? DP[i - 1] : 0; 이 되겠지. +// 이렇게 하면 시간복잡도 O(n) 공간복잡도 O(n)이라 내 풀이보다 훨씬좋다 + +class Solution { + + public int maxSubArray(int[] nums) { + int[] DP = new int[nums.length + 1]; + int maxSum = - 200000; + + for (int i = 0 ; i < nums.length; i ++) { + DP[i + 1] = nums[i] + (DP[i] > 0 ? DP[i] : 0); + maxSum = Math.max(maxSum, DP[i + 1]); + } + + return maxSum; + } +} From e6298d9579e02ea35b38d0d0914dd65544996280 Mon Sep 17 00:00:00 2001 From: namucy Date: Sat, 4 Jul 2026 14:03:32 +0900 Subject: [PATCH 3/5] number of 1 bits solution --- number-of-1-bits/namuuCY.java | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 number-of-1-bits/namuuCY.java diff --git a/number-of-1-bits/namuuCY.java b/number-of-1-bits/namuuCY.java new file mode 100644 index 0000000000..4b74d61d7d --- /dev/null +++ b/number-of-1-bits/namuuCY.java @@ -0,0 +1,20 @@ +// 문제풀이 흐름 +// 어떤 숫자를 2진수로 나타냈을때, 1의 개수를 구하는 것이므로 +// 2진수 변환과정에서 나오는 모든 1의 갯수만 세면 된다. + +// 숫자 n에 대하여 +// 시간복잡도 : O(logn) +// 공간복잡도 : O(1) + +class Solution { + public int hammingWeight(int n) { + int answer = 0; + + while (n > 0) { + if (n % 2 == 1) answer ++; + n /= 2; + } + + return answer; + } +} From 32bbf769b99ebf1a3aac64b6d8a65fc250dad3bd Mon Sep 17 00:00:00 2001 From: namucy Date: Sat, 4 Jul 2026 14:20:59 +0900 Subject: [PATCH 4/5] combination sum solution --- combination-sum/namuuCY.java | 41 ++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 combination-sum/namuuCY.java diff --git a/combination-sum/namuuCY.java b/combination-sum/namuuCY.java new file mode 100644 index 0000000000..2116800a53 --- /dev/null +++ b/combination-sum/namuuCY.java @@ -0,0 +1,41 @@ +// 문제풀이 흐름 +// 하나를 집어넣고, 모자라면 이전과 동일한걸 집어넣거나 더 큰걸 집어넣는 방식으로 계속 확인 +// -> 백트래킹 방식 + +// n = candidates.length / m = candidates[0] 라 할때, +// 시간복잡도 : +// 이론상 O(n ^ (target / m)) +// 150 조합 이내로 뽑히게끔 만들어뒀으므로 알아서 잘되지 않았을까... +// 공간복잡도 : +// O(target / m) - 재귀 깊이만큼 + + +class Solution { + + List> answer = new ArrayList<>(); + int[] candidates; + int target; + + public List> combinationSum(int[] candidates, int target) { + this.candidates = candidates; + this.target = target; + + backtracking(new ArrayList<>(), 0, target); + return answer; + } + + public void backtracking(List combination, int currentIdx, int remainder) { + if (remainder == 0) { + answer.add(new ArrayList<>(combination)); + return; + } else if (remainder < 0) { + return; + } + + for (int i = currentIdx ; i < candidates.length ; i++) { + combination.add(candidates[i]); + backtracking(combination, i, remainder - candidates[i]); + combination.remove(combination.size() - 1); + } + } +} From c4fb0b9a78eb01e546c9bf9c159f0587a6343d0e Mon Sep 17 00:00:00 2001 From: namucy Date: Sat, 4 Jul 2026 15:51:58 +0900 Subject: [PATCH 5/5] decode ways solution --- decode-ways/namuuCY.java | 60 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) create mode 100644 decode-ways/namuuCY.java diff --git a/decode-ways/namuuCY.java b/decode-ways/namuuCY.java new file mode 100644 index 0000000000..145e762026 --- /dev/null +++ b/decode-ways/namuuCY.java @@ -0,0 +1,60 @@ +// 문제 풀이 흐름 +// DP[i] = i - 1 번째 인덱스 char를 끝으로 하는 조합 +// 문제는 case를 다 분리할 수 밖에 없는건가? +// 7~9 이면 앞자리가 1인지 확인 -> 있으면 두가지 합해야함 / 아니면 한가지만 +// 0이면 앞자리가 반드시 1,2 이어야함 -> 무조건 한가지 +// 1~6이면 앞자리가 1,2인지 확인 -> 있으면 두가지 합해야함 / 아니면 한가지만 +// 이러면 너무 더러운 느낌? +// if () { +// if () +// } else if () { +// if () +// } else { +// } + +// 추가적으로 고려하지 못한 사항 : 01, 001 과 같은 경우 + +// n = s의 길이 +// 시간복잡도 : O(n) +// 공간복잡도 : O(n) + + +class Solution { + + String s; + int length; + int[] DP; + + public int numDecodings(String s) { + + this.s = s; + this.length = s.length(); + this.DP = new int[this.length + 1]; + + DP[0] = 1; + + for (int i = 1 ; i < this.length + 1; i ++) { + + if (canDecodeSingle(i)) { + DP[i] += DP[i - 1]; + } + + if (i >= 2 && canDecodePair(i)) { + DP[i] += DP[i - 2]; + } + } + + return DP[this.length]; + } + + private boolean canDecodeSingle(int currentIdx) { + return s.charAt(currentIdx - 1) != '0'; + } + + private boolean canDecodePair(int currentIdx) { + char currentChar = s.charAt(currentIdx - 1); + char prevChar = s.charAt(currentIdx - 2); + return prevChar == '1' + || (prevChar == '2' && currentChar <= '6'); + } +}