Merge branch 'DaleStudy:main' into week3

Author: grapefruitgreentealoe

.github/pull_request_template.md

@@ -12,7 +12,6 @@
 
 ## 작성자 체크 리스트
 
-- [ ] 우측 메뉴에서 PR을 **Projects**에 추가해주세요.
 - [ ] **Projects**의 오른쪽 버튼(▼)을 눌러 확장한 뒤, **Week**를 현재 주차로 설정해주세요.
 - [ ] 문제를 모두 푸시면 프로젝트에서 **Status**를 `In Review`로 설정해주세요.
 - [ ] 코드 검토자 1분 이상으로부터 승인을 받으셨다면 PR을 병합해주세요.

3sum/Geegong.java

@@ -0,0 +1,82 @@
+import java.util.*;
+
+public class Geegong {
+
+    /**
+     * Time complexity : O(n^2)
+     * space complexity : O(n^2)
+     * @param nums
+     * @return
+     */
+    public List<List<Integer>> threeSum(int[] nums) {
+
+        // 중복되는 값은 없어야 하기에 HashSet 으로 result
+        HashSet<List<Integer>> result = new HashSet<>();
+
+        // Key : 배열 원소 , value : List<String> 인덱스들
+        // elementMap 은 two pointer 의 값을 더한 값에서 0이 되기 위한 요소를 찾기위해 사용될 것임
+        // tc : O(n)
+        Map<Integer, List<Integer>> elementMap = new HashMap<>();
+        for (int index = 0; index<nums.length; index++) {
+            int value = nums[index];
+            if (elementMap.containsKey(value)) {
+                List<Integer> indices = elementMap.get(value);
+                indices.add(index);
+                elementMap.put(value, indices);
+            } else {
+                List<Integer> newIndices = new ArrayList<>();
+                newIndices.add(index);
+                elementMap.put(value, newIndices);
+            }
+        }
+
+        // leftIndex : 0에서 부터 시작하는 index
+        // rightIndex : nums.length - 1에서부터 감소하는 index
+        // leftIndex > rightIndex 되는 순간까지만 for문을 돌 것이다.
+        // tc : O(N^2 / 2)
+        for (int leftIndex=0; leftIndex < nums.length; leftIndex++) {
+            for (int rightIndex=nums.length - 1; rightIndex >= 0; rightIndex--) {
+
+                if (leftIndex >= rightIndex) {
+                    break;
+                }
+
+
+                int leftValue = nums[leftIndex];
+                int rightValue = nums[rightIndex];
+
+                int neededValueToZero = -leftValue - rightValue;
+                if (elementMap.containsKey(neededValueToZero)) {
+                    // elementMap의 value 가 leftIndex, rightIndex 은 아닌지 확인
+
+                    List<Integer> indices = elementMap.get(neededValueToZero);
+                    // zero 를 만들 수 있는 세번쨰 인덱스가 있는지 확인
+                    int thirdIndex = findThirdIndexToBeZero(leftIndex, rightIndex, indices);
+                    if (-1 != thirdIndex) {
+                        List<Integer> newOne = new ArrayList<>();
+                        newOne.add(nums[leftIndex]);
+                        newOne.add(nums[rightIndex]);
+                        newOne.add(nums[thirdIndex]);
+                        result.add(newOne.stream().sorted().toList());
+                    }
+
+                }
+
+            }
+        }
+
+        return result.stream().toList();
+
+    }
+
+    public int findThirdIndexToBeZero(int leftIndex, int rightIndex, List<Integer> indices) {
+        for (int index : indices) {
+            if (index != leftIndex && index != rightIndex) {
+                return index;
+            }
+        }
+
+        return -1;
+    }
+}
+

3sum/HISEHOONAN.swift

@@ -0,0 +1,48 @@
+//
+//  241.swift
+//  Algorithm
+//
+//  Created by 안세훈 on 4/8/25.
+//
+
+//3Sum
+class Solution { //정렬 + two pointer
+    func threeSum(_ nums: [Int]) -> [[Int]] {
+        let nums = nums.sorted() //배열을 오름차순으로 정렬
+        var result: [[Int]] = [] // 결과를 저장할 배열.
+
+        for i in 0..<nums.count { // i를 0번째 배열부터 순회.
+            if i > 0 && nums[i] == nums[i - 1] {
+                continue
+            }
+
+            var left = i + 1 //left는 i+1번째 인덱스
+            var right = nums.count - 1 //right는 배열의 끝번째 인덱스
+
+            while left < right {
+                let sum = nums[i] + nums[left] + nums[right]
+
+                if sum == 0 {
+                    result.append([nums[i], nums[left], nums[right]])
+
+                    // 중복 제거
+                    while left < right && nums[left] == nums[left + 1] {
+                        left += 1
+                    }
+                    while left < right && nums[right] == nums[right - 1] {
+                        right -= 1
+                    }
+
+                    left += 1
+                    right -= 1
+                } else if sum < 0 {
+                    left += 1
+                } else {
+                    right -= 1
+                }
+            }
+        }
+
+        return result
+    }
+}

3sum/HoonDongKang.ts

@@ -0,0 +1,39 @@
+/**
+ * [Problem]: [15] 3Sum
+ * (https://leetcode.com/problems/3sum/description/)
+ */
+
+function threeSum(nums: number[]): number[][] {
+    //시간 복잡도: O(n^2)
+    //공간 복잡도: O(1)
+    function pointerFunc(nums: number[]): number[][] {
+        const result: number[][] = [];
+        nums.sort((a, b) => a - b);
+
+        for (let i = 0; i < nums.length; i++) {
+            if (i > 0 && nums[i] === nums[i - 1]) continue;
+            let left = i + 1;
+            let right = nums.length - 1;
+
+            while (left < right) {
+                const sum = nums[i] + nums[left] + nums[right];
+                if (sum === 0) {
+                    result.push([nums[i], nums[left], nums[right]]);
+
+                    while (left < right && nums[left] === nums[left + 1]) left++;
+                    while (left < right && nums[right] === nums[right - 1]) right--;
+
+                    left++;
+                    right--;
+                } else if (sum < 0) {
+                    left++;
+                } else {
+                    right--;
+                }
+            }
+        }
+        return result;
+    }
+
+    return pointerFunc(nums);
+}

3sum/JEONGBEOMKO.java

@@ -0,0 +1,36 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+    /*
+    time complexity: O(n^2)
+    space complexity: O(1)
+     */
+        Arrays.sort(nums);
+        List<List<Integer>> result = new ArrayList<>();
+
+        for (int i = 0; i < nums.length - 2; i++) {
+            if (i > 0 && nums[i] == nums[i - 1]) continue;
+
+            int left = i + 1, right = nums.length - 1;
+
+            while (left < right) {
+                int sum = nums[i] + nums[left] + nums[right];
+
+                if (sum < 0) {
+                    left++;
+                } else if (sum > 0) {
+                    right--;
+                } else {
+                    result.add(Arrays.asList(nums[i], nums[left], nums[right]));
+                    while (left < right && nums[left] == nums[left + 1]) left++;
+                    while (left < right && nums[right] == nums[right - 1]) right--;
+                    left++; right--;
+                }
+            }
+        }
+        return result;
+    }
+}

3sum/Jeehay28.ts

@@ -0,0 +1,101 @@
+// Approach 3
+// 🗓️ 2025-04-12
+// ⏳ Time Complexity: O(n log n) + O(n^2) = O(n^2)
+// 💾 Space Complexity: O(1) (excluding output)
+
+function threeSum(nums: number[]): number[][] {
+
+    nums.sort((a, b) => a - b); // O(n log n)
+    let result: number[][] = [];
+
+    for (let i = 0; i < nums.length; i++) {
+
+        if (i > 0 && nums[i - 1] == nums[i]) continue; // skip duplicate i
+
+        let low = i + 1, high = nums.length - 1;
+        // two-pointer scan (low and high) -> takes up to O(n) time per iteration
+        while (low < high) {
+            const threeSum = nums[i] + nums[low] + nums[high];
+            if (threeSum < 0) {
+                low += 1;
+            } else if (threeSum > 0) {
+                high -= 1;
+            } else {
+                result.push([nums[i], nums[low], nums[high]]);
+
+                while (low < high && nums[low] === nums[low + 1]) low += 1 // skip duplicate low
+                while (low < high && nums[high] === nums[high - 1]) high -= 1 // skip duplicate high
+
+                low += 1;
+                high -= 1;
+
+            }
+        }
+    }
+    return result
+}
+
+
+// Approach 2
+// 🗓️ 2025-04-11
+// ❌ Time Limit Exceeded 313 / 314 testcases passed
+// ⏳ Time Complexity: O(n^2)
+// 💾 Space Complexity: O(n^2)
+
+// function threeSum(nums: number[]): number[][] {
+//   const result: number[][] = [];
+//   const triplets = new Set<string>();
+
+//   for (let i = 0; i < nums.length - 2; i++) {
+//     const seen = new Set<number>();
+//     for (let j = i + 1; j < nums.length; j++) {
+//       const twoSum = nums[i] + nums[j];
+//       if (seen.has(-twoSum)) {
+//         const triplet = [nums[i], nums[j], -twoSum].sort((a, b) => a - b); // O(log 3) = O(1)
+//         const key = triplet.join(",");
+//         if (!triplets.has(key)) {
+//           triplets.add(key);
+//           result.push(triplet);
+//         }
+//       }
+//       seen.add(nums[j]);
+//     }
+//   }
+//   return result;
+// }
+
+
+// Approach 1
+// 🗓️ 2025-04-11
+// ❌ Time Limit Exceeded!
+// ⏳ Time Complexity: O(n^3)
+// 💾 Space Complexity: O(n^2)
+
+// function threeSum(nums: number[]): number[][] {
+
+//     let triplets = new Set<string>();
+//     let result: number[][] = [];
+
+//     // const set = new Set();
+//     // set.add([1, 2, 3]);
+//     // set.add([1, 2, 3]);
+//     // console.log(set); // contains BOTH arrays
+//     // Set(2) { [ 1, 2, 3 ], [ 1, 2, 3 ] }
+
+//     for (let i = 0; i < nums.length - 2; i++) {
+//         for (let j = i + 1; j < nums.length - 1; j++) {
+//             for (let k = j + 1; k < nums.length; k++) {
+//                 if (nums[i] + nums[j] + nums[k] === 0) {
+//                     const triplet = [nums[i], nums[j], nums[k]].sort((a, b) => a - b);
+//                     const key = triplet.join(",");
+//                     if (!triplets.has(key)) {
+//                         triplets.add(key);
+//                         result.push(triplet)
+//                     }
+//                 }
+//             }
+//         }
+//     }
+
+//     return result;
+// };

3sum/JustHm.swift

@@ -0,0 +1,28 @@
+class Solution {
+    // time: O(n2) space: O(n)..?
+    func threeSum(_ nums: [Int]) -> [[Int]] {
+        let nums = nums.sorted() // hashmap 방식으로는 안될거 같아 정렬후 순차탐색 하기
+        
+        var answer = Set<[Int]>() // 중복 제거를 위해 Set으로 선언
+        for i in nums.indices {
+            var left = i + 1
+            var right = nums.count - 1
+            while left < right {
+                let result = nums[left] + nums[right] + nums[i]
+                if result == 0 {
+                    answer.insert([nums[i], nums[left], nums[right]])
+                    // 포인터 옮겨주고 더 검사하기
+                    right -= 1
+                    left += 1
+                }
+                else if result > 0 {
+                    right -= 1
+                }
+                else {
+                    left += 1
+                }
+            }
+        }
+        return Array(answer)
+    }
+}

3sum/KwonNayeon.py

@@ -3,14 +3,35 @@
 1. 3 <= nums.length <= 3000
 2. -10^5 <= nums[i] <= 10^5
 
-Time Complexity:
-    - O(n^2) (정렬은 O(n log n), 이중 반복문은 O(n^2))
-Space Complexity:
-    - O(n) (결과 리스트)
+Time Complexity: O(n^2)
+- 정렬은 O(n log n), 이중 반복문은 O(n^2)
+Space Complexity: O(n)
+- 결과 리스트를 저장하는 데 필요한 공간
+
+풀이 방법:
+- 투 포인터를 활용하여 합이 0이 되는 세 수 조합 찾기
+- 배열 정렬: 투 포인터 사용 + 중복 처리 용이
+- for 루프: 첫 번째 숫자 선택 (len(nums)-2까지)
+  - 중복된 첫 번째 숫자 건너뛰기
+  - left, right 포인터 설정
+- while 루프: 두 포인터가 교차하지 않아야 함
+  - sum = nums[i] + nums[left] + nums[right] 계산
+  - sum == 0: 결과 추가, 중복 건너뛰기, 양쪽 포인터 이동
+  - sum < 0: left 증가 (더 큰 값 필요)
+  - sum > 0: right 감소 (더 작은 값 필요)
+- 최종 결과 반환
 """
+# Brute-force: three nested loops → O(n^3)
+# Optimized: sort + two pointer → O(n^2)
 
 class Solution:
     def threeSum(self, nums: List[int]) -> List[List[int]]:
+        # Step 1: Sort the array
+        # Step 2: Fix one number using for loop
+        # Step 3: Use two pointers to find two other numbers
+        #   - if sum == 0: valid triplet
+        #   - if sum < 0: move left pointer
+        #   - if sum > 0: move right pointer
         nums.sort()
         result = []