Merge branch 'DaleStudy:main' into main

Author: KwonNayeon

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/PDKhan.cpp

@@ -0,0 +1,36 @@
+class Solution {
+    public:
+        vector<vector<int>> threeSum(vector<int>& nums) {
+            vector<vector<int>> result;
+            sort(nums.begin(), nums.end());
+    
+            for(int i = 0; i < nums.size(); i++){
+                if(i > 0 && nums[i] == nums[i-1])
+                    continue;
+                
+                int left = i + 1;
+                int right = nums.size() - 1;
+    
+                while(left < right){
+                    int sum = nums[i] + nums[left] + nums[right];
+    
+                    if(sum == 0){
+                        result.push_back({nums[i], nums[left], nums[right]});
+                        left++;
+                        right--;
+    
+                        while(left < right && nums[left] == nums[left-1])
+                            left++;
+                    
+                        while(left < right && nums[right] == nums[right+1])
+                            right--;
+                    }else if(sum < 0)
+                        left++;
+                    else
+                        right--;
+                }
+            }
+    
+            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/Tessa1217.java

@@ -0,0 +1,63 @@
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+// 정수 배열 nums가 주어질 때 nums[i], nums[j], nums[k]로 이루어진 배열을 반환하시오
+// 반환 배열 조건: i 가 j와 같지 않고, i가 k와 같지 않으며 세 요소의 합이 0인 배열
+class Solution {
+
+    // 시간복잡도: O(n^2)
+    public List<List<Integer>> threeSum(int[] nums) {
+
+        Arrays.sort(nums);
+
+        List<List<Integer>> answer = new ArrayList<>();
+
+        int left = 0;
+        int right = 0;
+        int sum = 0;
+
+        for (int i = 0; i < nums.length - 2 && nums[i] <= 0; i++) {
+
+            // 중복 제거
+            if (i > 0 && nums[i] == nums[i - 1]) {
+                continue;
+            }
+
+            left = i + 1;
+            right = nums.length - 1;
+
+            while (left < right) {
+
+                sum = nums[i] + nums[left] + nums[right];
+                // System.out.println(String.format("%d, %d, %d", i, left, right));
+                // System.out.println(String.format("%d + %d + %d = %d", nums[i], nums[left], nums[right], sum));
+                if (sum < 0) {
+                    left++;
+                    continue;
+                }
+                if (sum > 0) {
+                    right--;
+                    continue;
+                }
+
+                answer.add(List.of(nums[i], nums[left], nums[right]));
+
+                // 중복 제거
+                while (left < right && left + 1 < nums.length && nums[left] == nums[left + 1]) {
+                    left++;
+                }
+                while (left < right && right - 1 >= 0 && nums[right] == nums[right - 1]) {
+                    right--;
+                }
+                left++;
+                right--;
+
+            }
+        }
+
+        return answer;
+    }
+
+}
+