diff --git a/contains-duplicate/HoonDongKang.ts b/contains-duplicate/HoonDongKang.ts new file mode 100644 index 000000000..72b86f3c0 --- /dev/null +++ b/contains-duplicate/HoonDongKang.ts @@ -0,0 +1,41 @@ +/** + * [Problem]: [217] Contains Duplicate + * (https://leetcode.com/problems/contains-duplicate/description/) + */ + +function containsDuplicate(nums: number[]): boolean { + // 시간복잡도: O(n^2) + // 공간복잡도: O(1) + const doubleLoopFunc = (nums: number[]) => { + let isDuplicated = false; + for (let i = 0; i < nums.length; i++) { + for (let j = i + 1; j < nums.length; j++) { + if (nums[i] === nums[j]) isDuplicated = true; + } + } + return isDuplicated; + }; + + // 시간복잡도: O(n) + // 공간복잡도: O(n) + const setFunc = (nums: number[]) => { + const numsSet = new Set(nums); + + return nums.length !== numsSet.size; + }; + + // 시간복잡도: O(n) + // 공간복잡도: O(n) + const mapFunc = (nums: number[]) => { + const numsMap = new Map(); + + for (const num of nums) { + if (numsMap.get(num)) return true; + numsMap.set(num, true); + } + + return false; + }; + + return mapFunc(nums); +} diff --git a/house-robber/HoonDongKang.ts b/house-robber/HoonDongKang.ts new file mode 100644 index 000000000..1721ac33c --- /dev/null +++ b/house-robber/HoonDongKang.ts @@ -0,0 +1,54 @@ +/** + * [Problem]: [198] House Robber + * (https://leetcode.com/problems/house-robber/description/) + */ +function rob(nums: number[]): number { + // 시간 복잡도 O(2^n) + // 공간 복잡도 O(n) + // 시간 초과 + function recursionFunc(nums: number[]): number { + function getMax(start: number): number { + if (nums.length - 1 < start) return 0; + return Math.max(nums[start] + getMax(start + 2), getMax(start + 1)); + } + + return getMax(0); + } + + // 메모이제이션 + // 시간복잡도 O(n) + // 공간복잡도 O(n) + function memoizationFunc(nums: number[]): number { + let memoArr = new Array(nums.length).fill(-1); + function getMax(start: number): number { + if (nums.length - 1 < start) return 0; + if (memoArr[start] !== -1) return memoArr[start]; + + memoArr[start] = Math.max(nums[start] + getMax(start + 2), getMax(start + 1)); + + return memoArr[start]; + } + + return getMax(0); + } + + // DP + // 시간복잡도 O(n) + // 공간복잡도 O(1) + function dpSolution(nums: number[]): number { + if (nums.length === 1) return nums[0]; + + let prev2 = 0; + let prev1 = 0; + + for (let num of nums) { + let current = Math.max(prev1, prev2 + num); + prev2 = prev1; + prev1 = current; + } + + return prev1; + } + + return dpSolution(nums); +} diff --git a/longest-consecutive-sequence/HoonDongKang.ts b/longest-consecutive-sequence/HoonDongKang.ts new file mode 100644 index 000000000..75429d315 --- /dev/null +++ b/longest-consecutive-sequence/HoonDongKang.ts @@ -0,0 +1,30 @@ +/** + * [Problem]: [128] Longest Consecutive Sequence + * (https://leetcode.com/problems/longest-consecutive-sequence/description/) + */ + +function longestConsecutive(nums: number[]): number { + // 시간 복잡도 O(n) + // 공간 복잡도 O(n) + function sortFunc(nums: number[]): number { + const setArr = new Set(nums); + let longestCount = 0; + + for (let num of setArr) { + if (!setArr.has(num - 1)) { + let current = num; + let count = 1; + + while (setArr.has(current + 1)) { + current++; + count++; + } + + longestCount = Math.max(count, longestCount); + } + } + return longestCount; + } + + return sortFunc(nums); +} diff --git a/product-of-array-except-self/HoonDongKang.ts b/product-of-array-except-self/HoonDongKang.ts new file mode 100644 index 000000000..2f18b771b --- /dev/null +++ b/product-of-array-except-self/HoonDongKang.ts @@ -0,0 +1,36 @@ +/** + * [Problem]: [238] Product of Array Except Self + * (https://leetcode.com/problems/product-of-array-except-self/description/) + */ + +function productExceptSelf(nums: number[]): number[] { + // 시간 복잡도 O(n^2) + // 공간 복잡도 O(n) + // 시간 초과로 실패 + function doubleLoopFunc(nums: number[]): number[] { + return nums.map((_, i) => nums.reduce((acc, cur, j) => (i === j ? acc : acc * cur), 1)); + } + + // 시간 복잡도 O(n) + // 공간 복잡도 O(n) + function separateFunc(nums: number[]): number[] { + const length = nums.length; + const result: number[] = new Array(length).fill(1); + let leftProduct = 1; + let rightProduct = 1; + + for (let i = 0; i < length; i++) { + result[i] = leftProduct; + leftProduct *= nums[i]; + } + + for (let i = length - 1; i >= 0; i--) { + result[i] *= rightProduct; + rightProduct *= nums[i]; + } + + return result; + } + + return separateFunc(nums); +} diff --git a/two-sum/HoonDongKang.ts b/two-sum/HoonDongKang.ts new file mode 100644 index 000000000..bf3b87824 --- /dev/null +++ b/two-sum/HoonDongKang.ts @@ -0,0 +1,56 @@ +/** + * [Problem]: [001] Two Sum + * (https://leetcode.com/problems/two-sum/description/) + */ + +function twoSum(nums: number[], target: number): number[] { + // 시간 복잡도 O(n^2) + // 공간 복잡도 O(1) + function doubleLoopFunc(num: number[], target: number): number[] { + for (let i = 0; i < nums.length; i++) { + for (let j = i + 1; j < nums.length; j++) { + if (nums[i] + nums[j] === target) return [i, j]; + } + } + + return []; + } + + // 시간 복잡도 O(n) + // 공간 복잡도 O(n) + function differenceMap(nums: number[], target: number): number[] { + const diffMap = new Map(); + + for (let [i, num] of nums.entries()) { + const diff = target - num; + if (diffMap.has(diff)) return [i, diffMap.get(diff)!]; + diffMap.set(num, i); + } + + return []; + } + + // 시간 복잡도 O(nlog n) - sort + // 공간 복잡도 O(1) + // 정렬을 통해 인덱스 값을 유지할 수 없어서 실패 + // 인덱스 값이 아닌 배열의 요소를 반환하는 문제에서는 사용이 가능할 듯? + function twoPointerFunc(nums: number[], target: number): number[] { + nums.sort((a, b) => a - b); + let leftPointer = 0; + let rightPointer = nums.length - 1; + + while (leftPointer < rightPointer) { + const twoSum = nums[leftPointer] + nums[rightPointer]; + if (twoSum === target) return [leftPointer, rightPointer]; + + if (twoSum < target) leftPointer++; + if (twoSum > target) rightPointer--; + } + + return []; + } + + return twoPointerFunc(nums, target); +} + +console.log(twoSum([2, 7, 11, 15], 9));