[gomgom22] Week3

3sum/Yjason-K.ts

@@ -0,0 +1,53 @@
+/**
+ * 세 수의 합이 0이 되는 모든 고유한 조합을 찾는 함수
+ * 
+ * @param {number[]} nums - 정수 배열
+ * @returns {number[][]} - 세 수의 합이 0이 되는 조합 배열
+ * 
+ * 1. 입력 배열 `nums`를 오름차순으로 정렬.
+ * 2. 이중 반복문을 사용하여 각 요소를 기준으로 `투 포인터(two-pointer)`를 이용해 조합을 탐색.
+ * 3. 중복 조합을 방지하기 위해 `Set`을 사용하여 결과 조합의 문자열을 저장.
+ * 4. 조건에 맞는 조합을 `result` 배열에 추가합니다.
+ * 
+ * 시간 복잡도:
+ * - 정렬: O(n log n)
+ * - 이중 반복문 및 투 포인터: O(n^2)
+ * - 전체 시간 복잡도: O(n^2)
+ * 
+ * 공간 복잡도:
+ * - `Set` 및 `result` 배열에 저장되는 고유 조합: O(k), k는 고유한 조합의 수
+ * - 전체 공간 복잡도: O(n + k)
+ */
+function threeSum(nums: number[]): number[][] {
+    const sumSet = new Set<string>();
+    const result: number[][] = [];
+    nums.sort((a, b) => a - b);
+
+    // 첫 번째 요소를 기준으로 반복문 수행
+    for (let i = 0; i < nums.length - 2; i++) {
+        // 정렬 된 상태이기 때문에 시작점을 기준으로 다음 값 중복 비교
+        if (i > 0 && nums[i] === nums[i - 1]) continue;
+
+        let start = i + 1, end = nums.length - 1;
+        while (start < end) {
+            const sum = nums[i] + nums[start] + nums[end];
+            if (sum > 0) {
+                end--;
+            } else if (sum < 0) {
+                start++;
+            } else {
+                const triplet = [nums[i], nums[start], nums[end]];
+                const key = triplet.toString();
+                if (!sumSet.has(key)) {
+                    sumSet.add(key);
+                    result.push(triplet);
+                }
+                start++;
+                end--;
+            }
+        }
+    }
+
+    return result;
+}
+

product-of-array-except-self/Yjason-K.ts

@@ -0,0 +1,38 @@
+/**
+ * 주어진 배열에서 자신의 인덱스를 제외한 나머지 요소들의 곱을 계산하는 함수
+ *
+ * @param {number[]} nums - 정수 배열
+ * @returns {number[]} - 각 인덱스의 요소를 제외한 나머지 요소들의 곱을 구한 배열
+ *
+ * 1. 결과 배열 `result`를 1로 초기화.
+ * 2. 왼쪽에서 오른쪽으로 순회하며 `left` 값을 이용해 기준 idx 이전의 값을 계산하여 `result`에 저장.
+ * 3. 오른쪽에서 왼쪽으로 순회하며 `right` 값을 이용해 접미 기준 idx 이후의 값들을 계산 히야 `result`에 곱함. 
+ * 4. 결과 배열 `result`를 반환.
+ *
+ * 시간 복잡도:
+ * - 왼쪽에서 오른쪽 순회: O(n)
+ * - 오른쪽에서 왼쪽 순회: O(n)
+ * - 전체 시간 복잡도: O(n)
+ *
+ * 공간 복잡도:
+ * - 추가 배열 없이 상수 공간 사용 (result는 문제의 요구 조건에 포함되지 않음).
+ * - 전체 공간 복잡도: O(1)
+ */
+function productExceptSelf(nums: number[]): number[] {
+    const numLength = nums.length;
+    const result = new Array(numLength).fill(1);
+
+    let left = 1;
+    for (let i = 0; i < numLength; i++) {
+        result[i] *= left;
+        left *= nums[i];
+    }
+
+    let right = 1;
+    for (let i = numLength; i >= 0; i--) {
+        result[i] *= right;
+        right *= nums[i];
+    }
+
+    return result;
+}

reverse-bits/Yjason-K.ts

@@ -0,0 +1,22 @@
+/**
+ * 주어진 정수를 32비트로 변환하고 반전시켜 그때의 정수를 반환하는 문제.
+ * 
+ * @param {number} n - 정수 (32비트))
+ * @returns {number} - 2진수 변환 및 반전하여 정수 변환.
+ * 
+ * 내장 메서드를 사용하여 32비트 2진수 변환 후, reverse하여 다시 정수로 변환.
+ * 
+ * 시간 복잡도: O(32)
+ *  - 32비트 정수의 비트를 처리하므로 고정된 상수 시간.
+ * 
+ * 공간 복잡도: O(32)
+ *  - 2진수 문자열을 생성하고 반전된 문자열을 저장하므로 고정된 크기의 추가 메모리가 필요.
+ */
+function reverseBits(n: number): number {
+    // 숫자를 32비트 2진수 문자열로 변환 (앞에 0 채우기)
+    const binaryStr = n.toString(2).padStart(32, '0');
+    // 2진수 문자열을 뒤집기
+    const reversedBinaryStr = binaryStr.split('').reverse().join('');
+    // 뒤집힌 2진수 문자열을 다시 숫자로 변환
+    return parseInt(reversedBinaryStr, 2);
+};

two-sum/Yjason-K.ts

@@ -0,0 +1,25 @@
+/**
+ * 주어진 배열에서 두 숫자의 합이 target이 되는 idx 쌍을 반환하는 함수
+ * - 시간 복잡도: O(n)
+ *   - 한번의 배열을 순회하며 Map에 값을 저장하고, Map에서 값을 찾음
+ * - 공간 복잡도: O(n)
+ *  - 숫자와 그때의 idx를 쌍으로하는 Map
+ * 
+ * @param {number[]} nums  - 숫자 배열
+ * @param {number} target - 타겟 합
+ * @returns {number[]} - 합을 만들 수 있는 idx 배열
+ */
+function twoSum(nums: number[], target: number): number[] {
+  const map = new Map<number, number>();
+  for (let i = 0; i < nums.length; i++) {
+    const cur = nums[i]; // 현재 값
+    const reamin = target - cur; // 나머지
+    if (map.has(reamin)) {
+        // Non-null assertion operator(!)를 사용하여 undefined가 아님을 단언
+      return [map.get(reamin)!, i];
+    }
+    // 나머지를 찾지 못한 경우 현재 값을 저장
+    map.set(cur, i);
+  }
+  return []; // 목표 합을 만들 수 있는 숫자가 없는 경우 빈 배열 반환
+}