Merge branch 'DaleStudy:main' into main

Author: hoyeongkwak

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/Sung-Heon.py

@@ -0,0 +1,33 @@
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        nums.sort()
+        result = []
+        n = len(nums)
+
+        for i in range(n - 2):
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+
+            left = i + 1
+            right = n - 1
+
+            while left < right:
+                current_sum = nums[i] + nums[left] + nums[right]
+
+                if current_sum == 0:
+                    result.append([nums[i], nums[left], nums[right]])
+
+                    while left < right and nums[left] == nums[left + 1]:
+                        left += 1
+                    while left < right and nums[right] == nums[right - 1]:
+                        right -= 1
+
+                    left += 1
+                    right -= 1
+
+                elif current_sum < 0:
+                    left += 1
+                else:
+                    right -= 1
+
+        return result

3sum/Yn3-3xh.java

@@ -0,0 +1,39 @@
+/*
+[문제풀이]
+- nums 배열 안의 3가지 수를 더했을 때 0이어야 한다.
+- 더해진 수들의 index는 모두 달라야 한다.
+- DFS (X)
+    StackOverflowError
+- 투 포인터 (O)
+time: O(N^2), space: O(N^2)
+
+[회고]
+해설을 보고 이해는 했는데 다시 풀 수 있을까?
+아직 스킬이 부족한 것 같다..
+
+*/
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        Set<List<Integer>> answers = new HashSet<>();
+        Arrays.sort(nums);
+
+        for (int start = 0; start < nums.length; start++) {
+            int mid = start + 1;
+            int end = nums.length - 1;
+
+            while (mid < end) {
+                int sum = nums[start] + nums[mid] + nums[end];
+                if (sum == 0) {
+                    List<Integer> answer = List.of(nums[start], nums[mid], nums[end]);
+                    answers.add(answer);
+                    end--;
+                } else if (sum < 0) {
+                    mid++;
+                } else if (sum > 0) {
+                    end--;
+                }
+            }
+        }
+        return new ArrayList<>(answers);
+    }
+}

3sum/YoungSeok-Choi.java

@@ -0,0 +1,65 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+// NOTE: 실행시간 1.5초..
+// 시간 복잡도: O(n^2)
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+
+        Arrays.sort(nums);
+        Set<List<Integer>> result = new HashSet<>();
+
+        for(int i = 0; i < nums.length - 2; i++) {
+            int startIdx = i + 1;
+            int endIdx = nums.length - 1;
+            while(startIdx < endIdx) {
+                int sum = nums[i] + nums[startIdx] + nums[endIdx];
+                if(sum == 0) {
+                    result.add(Arrays.asList(nums[i], nums[startIdx], nums[endIdx]));
+                }
+
+                if(sum > 0) {
+                    endIdx--;
+                } else {
+                    startIdx++;
+                }
+            }
+        }
+
+        return new ArrayList<>(result);   
+    }
+}
+
+
+
+//  309 / 314 testcases passed Time Limit Exceeded
+// NOTE: 시간복잡도 O(n^3)
+class WrongSolution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        Set<List<Integer>> res = new HashSet<>();
+
+        List<Integer> temp = new ArrayList<>();
+
+        temp.remove(3);
+
+        for(int i = 0; i < nums.length; i++) {
+            for(int j = 0; j < i; j++) {
+                for(int k = 0; k < j; k++) {
+
+                    if((nums[i] + nums[j] + nums[k]) == 0) {
+                        List<Integer> solution = Arrays.asList(nums[i], nums[j], nums[k]);
+                        Collections.sort(solution);
+                        res.add(solution);
+                    }
+                }
+            }
+        }
+
+
+        return new ArrayList<>(res);
+    }
+}

3sum/ayleeee.py

@@ -0,0 +1,19 @@
+# 투포인터를 활용해보기
+
+def threeSum(self, nums: List[int]) -> List[List[int]]:
+    n = len(nums)
+    nums.sort()
+    result = set()
+    for i in range(n):
+        l,r = i+1,n-1
+        while l<r:
+            res = nums[i] + nums[l] + nums[r]
+            if res < 0:
+                l += 1
+            elif res > 0:
+                r -= 1
+            else:
+                result.add((nums[i], nums[l], nums[r]))
+                l += 1
+    return list(result)
+