Merge pull request #801 from mike2ox/main

[moonhyeok] Week3

combination-sum/mike2ox.ts

@@ -0,0 +1,27 @@
+/**
+ * source: https://leetcode.com/problems/combination-sum/
+ * 풀이방법: 재귀를 이용하여 모든 조합을 탐색
+ *
+ * 시간복잡도: O(n^m) (n: candidates의 길이, m: target을 만들기 위한 최대 반복 횟수)
+ * 공간복잡도: O(n^m) (n: candidates의 길이, m: target을 만들기 위한 최대 반복 횟수)
+ *
+ * Note
+ * - 당장에 구현하려다보니 재귀를 이용한 방법으로 구현. => 추후 리팩토링 필요
+ */
+function combinationSum(candidates: number[], target: number): number[][] {
+  if (target === 0) return [[]];
+  if (target < 0) return [];
+
+  const result: number[][] = [];
+
+  for (let i = 0; i < candidates.length; i++) {
+    const num = candidates[i];
+    const subCombos = combinationSum(candidates.slice(i), target - num);
+
+    for (const combo of subCombos) {
+      result.push([num, ...combo]);
+    }
+  }
+
+  return result;
+}

maximum-subarray/mike2ox.ts

@@ -0,0 +1,22 @@
+/**
+ * source: https://leetcode.com/problems/maximum-subarray/
+ * 풀이방법: 현재 위치까지의 최대 합을 저장하면서 전체 최대 합을 갱신
+ * 시간복잡도: O(n) (n: nums의 길이)
+ * 공간복잡도: O(1) (상수 공간만 사용)
+ */
+function maxSubArray(nums: number[]): number {
+  // 배열이 비어있는 경우
+  if (nums.length === 0) return 0;
+
+  let result = nums[0]; // 전체 최대 합(초기값은 첫 번째 요소)
+  let current = nums[0]; // 현재 위치까지의 최대 합
+
+  for (let i = 1; i < nums.length; i++) {
+    // 현재 요소를 더한 값과 현재 요소 중 큰 값을 선택
+    current = Math.max(nums[i], current + nums[i]);
+    // 전체 최대 합 갱신
+    result = Math.max(result, current);
+  }
+
+  return result;
+}

product-of-array-except-self/mike2ox.ts

@@ -0,0 +1,25 @@
+/**
+ * source: https://leetcode.com/problems/product-of-array-except-self/
+ * 풀이방법: 왼쪽부터의 누적 곱과 오른쪽부터의 누적 곱을 이용하여 결과 계산
+ * 시간복잡도: O(n) (n: nums의 길이)
+ * 공간복잡도: O(1) (상수 공간만 사용)
+ */
+function productExceptSelf(nums: number[]): number[] {
+  const n = nums.length;
+  const result = new Array(n);
+
+  // 왼쪽부터의 누적 곱 계산
+  result[0] = 1;
+  for (let i = 1; i < n; i++) {
+    result[i] = result[i - 1] * nums[i - 1];
+  }
+
+  // 오른쪽부터의 누적 곱을 곱하면서 결과 계산
+  let right = 1;
+  for (let i = n - 1; i >= 0; i--) {
+    result[i] = result[i] * right;
+    right *= nums[i];
+  }
+
+  return result;
+}

reverse-bits/mike2ox.ts

@@ -0,0 +1,16 @@
+/**
+ * source: https://leetcode.com/problems/reverse-bits/
+ * 풀이방법: 비트 연산을 이용하여 뒤집기
+ * 시간복잡도: O(1)
+ * 공간복잡도: O(1)
+ */
+function reverseBits(n: number): number {
+  let result = 0;
+  const bitSize = 32;
+  // 32비트를 순회하면서 뒤집기
+  for (let i = 0; i < bitSize; i++) {
+    const bit = (n >> i) & 1; // i번째 비트 추출
+    result = result | (bit << (bitSize - 1 - i)); // 뒤집은 비트를 result에 저장
+  }
+  return result >>> 0; // 부호비트를 제거하기 위해 0으로 비트 이동
+}

two-sum/mike2ox.ts

@@ -0,0 +1,23 @@
+/**
+ * Source: https://leetcode.com/problems/two-sum/
+ * 풀이방법: Map을 이용하여 필요한 나머지 숫자를 저장하면서 확인
+ * 시간복잡도: O(n)
+ * 공간복잡도: O(n)
+ */
+function twoSum(nums: number[], target: number): number[] {
+  // nums의 값을 key로, 인덱스를 value로 저장하는 Map
+  const numMap = new Map<number, number>();
+
+  for (let i = 0; i < nums.length; i++) {
+    const remain = target - nums[i]; // 필요한 나머지 숫자 계산
+
+    // 필요한 나머지 숫자가 Map에 있는지 체크
+    if (numMap.has(remain)) {
+      return [numMap.get(remain)!, i];
+    }
+    // 현재 숫자와 인덱스 저장
+    numMap.set(nums[i], i);
+  }
+
+  return [];
+}