Merge pull request #1160 from HoonDongKang/main

[HoonDongKang] WEEK 01 solutions

Author: HoonDongKang

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<number>(nums);
+
+    return nums.length !== numsSet.size;
+  };
+
+  // 시간복잡도: O(n)
+  // 공간복잡도: O(n)
+  const mapFunc = (nums: number[]) => {
+    const numsMap = new Map<number, boolean>();
+
+    for (const num of nums) {
+      if (numsMap.get(num)) return true;
+      numsMap.set(num, true);
+    }
+
+    return false;
+  };
+
+  return mapFunc(nums);
+}

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);
+}

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);
+}

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);
+}

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<number, number>();
+
+        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));