Merge branch 'DaleStudy:main' into main

Author: seongmin36

3sum/DaleSeo.rs

@@ -0,0 +1,37 @@
+// TC: O(n^2)
+// SC: O(1)
+impl Solution {
+    pub fn three_sum(mut nums: Vec<i32>) -> Vec<Vec<i32>> {
+        nums.sort_unstable();
+        let n = nums.len();
+        let mut triplets = Vec::new();
+
+        for i in 0..n {
+            if i > 0 && nums[i] == nums[i - 1] {
+                continue;
+            }
+
+            let (mut low, mut high) = (i + 1, n - 1);
+            while low < high {
+                let three_sum = nums[i] + nums[low] + nums[high];
+                if three_sum < 0 {
+                    low += 1;
+                } else if three_sum > 0 {
+                    high -= 1;
+                } else {
+                    triplets.push(vec![nums[i], nums[low], nums[high]]);
+                    low += 1;
+                    high -= 1;
+                    while low < high && nums[low] == nums[low - 1] {
+                        low += 1;
+                    }
+                    while low < high && nums[high] == nums[high + 1] {
+                        high -= 1;
+                    }
+                }
+            }
+        }
+
+        triplets
+    }
+}

3sum/ICE0208.java

@@ -0,0 +1,54 @@
+import java.util.*;
+
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        /*
+         * 세 수의 합이 0이 되는 조합을 찾는다.
+         *
+         * nums[i]를 하나 고정하면,
+         * 나머지 두 수를 찾는 Two Sum 문제로 바꿀 수 있다.
+         *
+         * seen에는 현재 i 기준으로 지나온 값들을 저장한다.
+         * target이 seen에 있으면 nums[i] + target + nums[j] = 0 이다.
+         *
+         *
+         * 시간 복잡도: O(n^2)
+         * 공간 복잡도: O(n)
+         */
+
+        Arrays.sort(nums);
+
+        List<List<Integer>> answer = new ArrayList<>();
+
+        for (int i = 0; i < nums.length; i++) {
+            // 같은 기준값은 한 번만 사용
+            if (i > 0 && nums[i] == nums[i - 1]) {
+                continue;
+            }
+
+            // 기준값이 양수면 합이 0이 될 수 없음
+            if (nums[i] > 0) {
+                break;
+            }
+
+            Set<Integer> seen = new HashSet<>();
+
+            for (int j = i + 1; j < nums.length; j++) {
+                int target = -nums[i] - nums[j];
+
+                if (seen.contains(target)) {
+                    answer.add(Arrays.asList(nums[i], target, nums[j]));
+
+                    // 같은 nums[j]는 중복 조합을 만들 수 있으므로 스킵
+                    while (j + 1 < nums.length && nums[j] == nums[j + 1]) {
+                        j++;
+                    }
+                }
+
+                seen.add(nums[j]);
+            }
+        }
+
+        return answer;
+    }
+}

3sum/JeonJe.java

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

3sum/JinuCheon.py

@@ -0,0 +1,87 @@
+# brute force 로 풀어본 답안. O(n3) 다. 역시 timeout.
+# dic, set 자료형 익히기 겸 해봤다. 파이썬 편하다 최고.
+class Solution:
+    def threeSum(self, nums: list[int]) -> list[list[int]]:
+        n = len(nums)
+        result = set()
+
+        for i in range(n):
+            for j in range(n):
+                for k in range(n):
+                    if (i == j or j == k or i == k):
+                        continue
+                    if (nums[i] + nums[j] + nums[k] == 0):
+                        result.add(tuple(sorted([nums[i], nums[j], nums[k]])))
+        
+        return list(result)
+
+# LLM 에게 힌트 얻어서 진행.
+# i != j, i != k, j != k 조건 때문에 정렬을 하면 안된다고 착각하고 있었다. 사실 고정된 순서는 중요하지 않음.
+# 정렬을 진행하고, two pointer 로 진행.
+# 통과!
+class Solution2:
+    def threeSum(self, nums: list[int]) -> list[list[int]]:
+        # 정렬
+        nums.sort()
+        n = len(nums)
+        result = set()
+
+        for i in range(n):
+            # i 자리 중복 skip (이전 원소와 같으면 건너뜀)
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+
+            # i + left + right === 0 이 되어야 함.
+            left = i + 1
+            right = n - 1
+
+            while left < right:
+                if nums[left] + nums[right] == -nums[i]:
+                    result.add(tuple([nums[i], nums[left], nums[right]]))
+                    left += 1
+                    right -= 1
+
+                elif nums[left] + nums[right] < -nums[i]:
+                    left += 1
+                else:
+                    right -= 1
+
+        return list(result)
+
+# LLM의 피드백.
+# 중복을 스킵하는 효율적인 방법이 있었음.
+class Solution:
+    def threeSum(self, nums: list[int]) -> list[list[int]]:
+        nums.sort()
+        n = len(nums)
+        result = []
+
+        for i in range(n):
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+
+            if nums[i] > 0:
+                break
+
+            left, right = i + 1, n - 1
+            target = -nums[i]
+
+            while left < right:
+                s = nums[left] + nums[right]
+                if s == target:
+                    result.append([nums[i], nums[left], nums[right]])
+                    left += 1
+                    right -= 1
+                    
+                    # left, right 자리도 중복 skip
+                    while left < right and nums[left] == nums[left - 1]:
+                        left += 1
+                    while left < right and nums[right] == nums[right + 1]:
+                        right -= 1
+                        
+                elif s < target:
+                    left += 1
+                else:
+                    right -= 1
+
+        return result

3sum/Yiseull.py

@@ -0,0 +1,27 @@
+class Solution:
+    def threeSum(self, nums: list[int]) -> list[list[int]]:
+        answer = set()
+
+        nums = sorted(nums)
+
+        n = len(nums)
+        for i in range(n - 2):
+            if nums[i] > 0:
+                break
+
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+
+            left, right = i + 1, n - 1
+            while left < right:
+                threeSum = nums[i] + nums[left] + nums[right]
+                if threeSum < 0:
+                    left += 1
+                elif threeSum == 0:
+                    answer.add((nums[i], nums[left], nums[right]))
+                    left += 1
+                    right -= 1
+                else:
+                    right -= 1
+
+        return list(answer)

3sum/Zero-1016.ts

@@ -0,0 +1,43 @@
+/**
+ * 시간 복잡도 O(n²)
+ * 공간 복잡도 O(log n)
+ *
+ * 접근: 오름차순 정렬 + 투 포인터
+ * - 기준 인덱스 i를 고정하고, left = i + 1, right = 끝에서 탐색
+ * - 정렬된 상태에서 같은 값을 건너뛰는 방식으로 중복 제거 (Set 불필요)
+ */
+function threeSum(nums: number[]): number[][] {
+  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;
+
+    // 최적화: 기준 숫자가 양수면 뒤의 숫자들도 모두 양수 → 합이 0 불가능
+    if (nums[i] > 0) break;
+
+    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;
+}

3sum/daehyun99.py

@@ -0,0 +1,51 @@
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        res = []
+        nums.sort()
+
+        for i, a in enumerate(nums):
+            if a > 0:
+                break
+            if i > 0 and a == nums[i-1]:
+                continue
+            
+            l, r = i+1, len(nums) - 1
+            while l < r:
+                total = a + nums[l] + nums[r]
+                if total > 0:
+                    r -= 1
+                elif total < 0:
+                    l += 1
+                else:
+                    res.append([a, nums[l], nums[r]])
+                    l += 1
+                    r -= 1
+                    while nums[l] == nums[l - 1] and l < r:
+                        l += 1
+        return res
+
+"""from collections import Counter
+
+class Solution:
+    def threeSum(self, nums: list[int]) -> list[list[int]]:
+        counts = Counter(nums)
+        result: set[tuple[int, int, int]] = set()
+
+        for i in range(len(nums) - 2):
+            for j in range(i + 1, len(nums) - 1):
+                adding = -(nums[i] + nums[j])
+
+                if adding not in counts:
+                    continue
+
+                local_counts = Counter([nums[i], nums[j], adding])
+
+                for num, count in local_counts.items():
+                    if counts[num] < count:
+                        break
+                else:
+                    triplet = tuple(sorted([nums[i], nums[j], adding]))
+                    result.add(triplet)
+
+        return [list(triplet) for triplet in result]
+"""