From 9aaee2e38e847a6bd3ab70b0b3a1cb68f3ccab9f Mon Sep 17 00:00:00 2001 From: HoonDongKang Date: Sat, 19 Apr 2025 21:34:15 +0900 Subject: [PATCH 1/5] add Valid Palindrome solution --- valid-palindrome/HoonDongKang.ts | 49 ++++++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) create mode 100644 valid-palindrome/HoonDongKang.ts diff --git a/valid-palindrome/HoonDongKang.ts b/valid-palindrome/HoonDongKang.ts new file mode 100644 index 000000000..95262fd4a --- /dev/null +++ b/valid-palindrome/HoonDongKang.ts @@ -0,0 +1,49 @@ +/** + * [Problem]: [125] Valid Palindrome + * + * (https://leetcode.com/problems/valid-palindrome/description/) + */ + +function isPalindrome(s: string): boolean { + // 시간복잡도: O(n) + // 공간복잡도: O(n) + function twoPointerFunc(s: string): boolean { + let stringArr: string[] = [...s.replace(/[^a-zA-Z0-9]/g, "")]; + let left = 0; + let right = stringArr.length - 1; + + while (left < right) { + if (stringArr[left].toLowerCase() === stringArr[right].toLowerCase()) { + left++; + right--; + } else { + return false; + } + } + + return true; + } + + // 시간복잡도: O(n) + // 공간복잡도: O(1) + function optimizedTwoPointerFunc(s: string): boolean { + let left = 0; + let right = s.length - 1; + + while (left < right) { + while (left < right && !isLetterOrDigit(s[left])) left++; + while (left < right && !isLetterOrDigit(s[right])) right--; + + if (s[left].toLowerCase() !== s[right].toLowerCase()) return false; + left++; + right--; + } + + return true; + + function isLetterOrDigit(c: string): boolean { + return /[a-zA-Z0-9]/.test(c); + } + } + return optimizedTwoPointerFunc(s); +} From f29b91f217049fd657eafc2b90d2a215ec0c7a46 Mon Sep 17 00:00:00 2001 From: HoonDongKang Date: Sat, 19 Apr 2025 21:34:24 +0900 Subject: [PATCH 2/5] add Number of 1 Bits solution --- number-of-1-bits/HoonDongKang.ts | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 number-of-1-bits/HoonDongKang.ts diff --git a/number-of-1-bits/HoonDongKang.ts b/number-of-1-bits/HoonDongKang.ts new file mode 100644 index 000000000..fca5569a1 --- /dev/null +++ b/number-of-1-bits/HoonDongKang.ts @@ -0,0 +1,31 @@ +/** + * [Problem]: [191] Number of 1 Bits + * + * (https://leetcode.com/problems/number-of-1-bits/description/) + */ +function hammingWeight(n: number): number { + // 시간 복잡도 O(log n) + // 공간 복잡도 O(1) + function divisionFunc(n: number): number { + let count = 0; + while (n > 0) { + count += n % 2; + n = Math.floor(n / 2); + } + + return count; + } + + // 시간 복잡도 O(log n) + // 공간 복잡도 O(1) + function bitwiseFunc(n: number): number { + let count = 0; + while (n !== 0) { + count += n & 1; + n = n >>> 1; + } + + return count; + } + return divisionFunc(n); +} From c3411170a5324732b17c5c0e53bf9b77640a8280 Mon Sep 17 00:00:00 2001 From: HoonDongKang Date: Sat, 19 Apr 2025 21:34:33 +0900 Subject: [PATCH 3/5] add Combination Sum solution --- combination-sum/HoonDongKang.ts | 54 +++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 combination-sum/HoonDongKang.ts diff --git a/combination-sum/HoonDongKang.ts b/combination-sum/HoonDongKang.ts new file mode 100644 index 000000000..ec841ac1f --- /dev/null +++ b/combination-sum/HoonDongKang.ts @@ -0,0 +1,54 @@ +/** + * [Problem]: [39] Combination Sum + * + * (https://leetcode.com/problems/combination-sum/description/) + */ +function combinationSum(candidates: number[], target: number): number[][] { + // 시간복잡도: O(c^t) + // 공간복잡도 O(t) + function dfsFunc(candidates: number[], target: number): number[][] { + let result: number[][] = []; + let nums: number[] = []; + + function dfs(start: number, total: number): void | number[][] { + if (total > target) return; + if (total === target) { + result.push([...nums]); + return result; + } + for (let i = start; i < candidates.length; i++) { + let num = candidates[i]; + nums.push(num); + dfs(i, total + num); + nums.pop(); + } + } + + dfs(0, 0); + return result; + } + + // 시간복잡도: O(c*t) + // 공간복잡도 O(c*t) + function dpFunc(candidates: number[], target: number): number[][] { + const dp: number[][][] = Array(target + 1) + .fill(null) + .map(() => []); + + dp[0] = [[]]; + + for (const num of candidates) { + for (let t = num; t <= target; t++) { + for (const comb of dp[t - num]) { + dp[t].push([...comb, num]); + } + } + } + + return dp[target]; + } + + return dpFunc(candidates, target); +} + +console.log(combinationSum([2, 3, 6, 7], 7)); From 13a8ffe5cedfbf42d5070c8437b473d18ac4cf66 Mon Sep 17 00:00:00 2001 From: HoonDongKang Date: Sat, 19 Apr 2025 22:58:07 +0900 Subject: [PATCH 4/5] add Decode Ways solution --- decode-ways/HoonDongKang.ts | 51 +++++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 decode-ways/HoonDongKang.ts diff --git a/decode-ways/HoonDongKang.ts b/decode-ways/HoonDongKang.ts new file mode 100644 index 000000000..f961b9683 --- /dev/null +++ b/decode-ways/HoonDongKang.ts @@ -0,0 +1,51 @@ +/** + * [Problem]: [91] Decode Ways + * + * (https://leetcode.com/problems/decode-ways/description/) + */ +function numDecodings(s: string): number { + //시간복잡도 O(n) + //공간복잡도 O(n) + function memoizationFunc(s: string): number { + const memoization: Record = {}; + + function dfs(index: number): number { + if (index in memoization) return memoization[index]; + if (index === s.length) return 1; + if (s[index] === "0") return 0; + + let result = dfs(index + 1); + if (index + 1 < s.length && +s.slice(index, index + 2) <= 26) { + result += dfs(index + 2); + } + + memoization[index] = result; + return result; + } + + return dfs(0); + } + + //시간복잡도 O(n) + //공간복잡도 O(1) + function optimizedFunc(s: string): number { + let prev2 = 1; + let prev1 = s[0] === "0" ? 0 : 1; + + for (let i = 1; i < s.length; i++) { + let curr = 0; + + const one = +s.slice(i, i + 1); + const two = +s.slice(i - 1, i + 1); + + if (one >= 1 && one <= 9) curr += prev1; + if (two >= 10 && two <= 26) curr += prev2; + + prev2 = prev1; + prev1 = curr; + } + + return prev1; + } + return optimizedFunc(s); +} From f92dbb52ad7c9bb524075f1a17f12d811b60ad93 Mon Sep 17 00:00:00 2001 From: HoonDongKang Date: Sat, 19 Apr 2025 23:44:12 +0900 Subject: [PATCH 5/5] add Maximum Subarray solution --- maximum-subarray/HoonDongKang.ts | 36 ++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 maximum-subarray/HoonDongKang.ts diff --git a/maximum-subarray/HoonDongKang.ts b/maximum-subarray/HoonDongKang.ts new file mode 100644 index 000000000..b4b044663 --- /dev/null +++ b/maximum-subarray/HoonDongKang.ts @@ -0,0 +1,36 @@ +/** + * [Problem]: [53] Maximum Subarray + * + * (https://leetcode.com/problems/maximum-subarray/description/) + */ + +function maxSubArray(nums: number[]): number { + //시간복잡도 O(n) + //공간복잡도 O(1) + function getMax(nums: number[]): number { + let result = nums[0]; + let sum = 0; + + nums.forEach((num) => { + sum = Math.max(num, sum + num); + result = Math.max(sum, result); + }); + + return result; + } + + //시간복잡도 O(n) + //공간복잡도 O(1) + function dpFunc(nums: number[]): number { + const dp = Array(nums.length).fill(0); + dp[0] = nums[0]; + + for (let i = 1; i < nums.length; i++) { + dp[i] = Math.max(nums[i], dp[i - 1] + nums[i]); + } + + return Math.max(...dp); + } + + return dpFunc(nums); +}