Merge branch 'DaleStudy:main' into week3

Author: mandoolala

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)
+

3sum/doitduri.swift

@@ -0,0 +1,43 @@
+import Foundation
+
+class Solution {
+    func threeSum(_ nums: [Int]) -> [[Int]] {
+        var result = [[Int]]()
+        let sortedNums = nums.sorted()
+        
+        for i in 0..<sortedNums.count - 2 {
+            if i > 0 && sortedNums[i] == sortedNums[i - 1] {
+                continue
+            }
+            
+            var leftNumber = i + 1
+            var rightNumber = sortedNums.count - 1
+            
+            while leftNumber < rightNumber {
+                let sum = sortedNums[i] + sortedNums[leftNumber] + sortedNums[rightNumber]
+                
+                if sum < 0 {
+                    leftNumber += 1
+                } else if sum > 0 {
+                    rightNumber -= 1
+                } else {
+                    result.append([sortedNums[i], sortedNums[leftNumber], sortedNums[rightNumber]])
+                    
+                    while leftNumber < rightNumber && sortedNums[leftNumber] == sortedNums[leftNumber + 1] {
+                        leftNumber += 1
+                    }
+                    
+                    while leftNumber < rightNumber && sortedNums[rightNumber] == sortedNums[rightNumber - 1] {
+                        rightNumber -= 1
+                    }
+                    
+                    leftNumber += 1
+                    rightNumber -= 1
+                }
+            }
+        }
+        
+        return result
+    }
+}
+

3sum/haung921209.md

@@ -0,0 +1,67 @@
+```cpp
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {
+        sort(nums.begin(), nums.end());
+        set<vector<int>> res;
+        for(int i=0;i<nums.size();i++){
+            int l = i+1, r = nums.size()-1;
+
+            while(l<r){
+                int sum = nums[i]+nums[l]+nums[r];
+
+                if(sum<0){
+                    l++;
+                }else if(sum>0){
+                    r--;
+                }else{
+                    res.insert({nums[i], nums[l], nums[r]});
+                    l++;
+                    r--;
+                }
+            }
+        }
+
+        return vector<vector<int>>(res.begin(), res.end());
+    }
+};
+```
+
+- set -> vector 사용 이유는 중복 제거를 위함
+
+```cpp
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {
+        sort(nums.begin(), nums.end());
+        set<vector<int>> res;
+        for(int i=0;i<nums.size();i++){
+            if(i != 0 && nums[i] == nums[i-1]) continue;
+
+            int l = i+1, r = nums.size()-1;
+
+            while(l<r){
+                int sum = nums[i]+nums[l]+nums[r];
+
+                if(sum<0){
+                    l++;
+                }else if(sum>0){
+                    r--;
+                }else{
+                    res.insert({nums[i], nums[l], nums[r]});
+                    l++;
+                    r--;
+                }
+            }
+        }
+
+        return vector<vector<int>>(res.begin(), res.end());
+
+    }
+};
+```
+
+- `if(i != 0 && nums[i] == nums[i-1]) continue;` 를 통한 탐색 범위 줄이기 최적화 정도의 차이로 상 / 하위 갈리는 정도
+- 단순 2 pointer로 처리해도 무방
+
+

3sum/hi-rachel.py

@@ -0,0 +1,16 @@
+# O(n^2) time, O(n) space
+
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        triplets = set()
+
+        for i in range(len(nums) - 2):
+            seen = set()
+            for j in range(i + 1, len(nums)):
+                complement = -(nums[i] + nums[j])
+                if complement in seen:
+                    triplet = [nums[i], nums[j], complement]
+                    triplets.add(tuple(sorted(triplet)))
+                seen.add(nums[j])
+
+        return list(triplets)

3sum/hoyeongkwak.ts

@@ -0,0 +1,30 @@
+/*
+time complexity : O(n^2)
+space complexity : O(1)
+*/
+function threeSum(nums: number[]): number[][] {
+    const result: number[][] = []
+    const sortedNums = nums.sort((a, b) => a - b)
+
+    for(let i = 0; i < sortedNums.length - 2; i++) {
+        if (i > 0 && sortedNums[i] === sortedNums[i - 1]) continue
+        let low = i + 1
+        let high = sortedNums.length - 1
+        while (low < high) {
+            const threeSum = sortedNums[i] + sortedNums[low] + sortedNums[high]
+            if (threeSum < 0) {
+                low += 1
+            } else if (threeSum > 0) {
+                high -= 1
+            } else {
+                result.push([sortedNums[i], sortedNums[low], sortedNums[high]])
+                while (low < high && sortedNums[low] === sortedNums[low + 1]) low++
+                while (low < high && sortedNums[high] === sortedNums[high - 1]) high--
+
+                low += 1
+                high -= 1
+            }
+        }
+    }
+    return result
+}

3sum/krokerdile.py

@@ -0,0 +1,58 @@
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        nums.sort()
+        res = []
+        n = len(nums)
+
+        for i in range(n):
+            if i > 0 and nums[i] == nums[i-1]:
+                continue
+
+            target = -nums[i]
+            seen = set()
+            j = i + 1
+
+            while j < n:
+                complement = target - nums[j]
+                if complement in seen:
+                    res.append([nums[i], complement, nums[j]])
+                    while j + 1 < n and nums[j] == nums[j+1]:
+                        j += 1
+                seen.add(nums[j])
+                j += 1
+        return list(set(tuple(x) for x in res))
+    
+
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        nums.sort()
+        result = []
+
+        for i in range(len(nums)):
+            # 중복된 첫 번째 수는 skip
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+
+            left, right = i + 1, len(nums) - 1
+
+            while left < right:
+                total = nums[i] + nums[left] + nums[right]
+
+                if total == 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 total < 0:
+                    left += 1  # 합이 작으면 왼쪽을 오른쪽으로
+                else:
+                    right -= 1  # 합이 크면 오른쪽을 왼쪽으로
+
+        return result

3sum/minji-go.java

@@ -1,41 +1,30 @@
-/*
-    Problem: https://leetcode.com/problems/3sum/
-    Description: return all the triplets (i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0)
-    Concept: Array, Two Pointers, Sorting
-    Time Complexity: O(N²), Runtime 70ms
-    Space Complexity: O(N), Memory 51.63MB
-*/
+/**
+ * <a href="https://leetcode.com/problems/3sum/">week02-4.3sum</a>
+ * Description: return all the triplets (i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0)
+ * Concept: Array, Two Pointers, Sorting
+ * Time Complexity: O(N²), Runtime 2021ms
+ * Space Complexity: O(N), Memory 53.9MB
+ */
+
 class Solution {
     public List<List<Integer>> threeSum(int[] nums) {
-        Map<Integer, Integer> number = new HashMap<>();
-        for(int i=0; i<nums.length; i++) {
-            number.put(nums[i], number.getOrDefault(nums[i], 0)+1);
+        Map<Integer, Integer> map = new HashMap<>();
+        for(int i=0; i<nums.length; i++){
+            map.put(nums[i], i);
         }
 
-        Arrays.sort(nums);
-        Set<List<Integer>> set = new HashSet<>();
-        List<List<Integer>> triplets = new ArrayList<>();
-        List<Integer> lastTriplet = null;
-        for(int i=0; i<nums.length-1; i++) {
-            if(i>0 && nums[i]==nums[i-1]) continue;
-
-            for(int j=i+1; j<nums.length; j++){
-                if(j>i+1 && nums[j]==nums[j-1]) continue;
-
-                int target = -(nums[i]+nums[j]);
-                if(nums[j]>target) continue;
-
-                int count = number.getOrDefault(target,0);
-                if(nums[i]==target) count--;
-                if(nums[j]==target) count--;
-                if(count<=0) continue;
-
-                List<Integer> triplet = List.of(nums[i], nums[j], target);
-                if(triplet.equals(lastTriplet)) continue;
-                lastTriplet = triplet;
-                triplets.add(triplet);
+        Set<List<Integer>> triplets = new HashSet<>();
+        for(int i=0; i<nums.length-2; i++){
+            for(int j=i+1; j<nums.length-1; j++){
+                int sum = nums[i]+nums[j];
+                if(map.containsKey(-sum) && map.get(-sum) > j){
+                    List<Integer> list = Arrays.asList(nums[i],nums[j],-sum);
+                    Collections.sort(list);
+                    triplets.add(list);
+                }
             }
         }
-        return triplets;
+
+        return new ArrayList<>(triplets);
     }
 }

3sum/paran22.py

@@ -0,0 +1,24 @@
+class Solution:
+    # time complexity: O(n^2)
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        nums.sort()
+        answer = set()
+
+        for i in range(len(nums) - 2):
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+
+            left, right = i + 1, len(nums) - 1
+            while left < right:
+                sum = nums[i] + nums[left] + nums[right]
+                if sum == 0:
+                    answer.add((nums[i], nums[left], nums[right]))
+                    left += 1
+                    right -= 1
+                elif sum > 0:
+                    right -= 1
+                elif sum < 0:
+                    left += 1
+
+        return [list(x) for x in answer]
+