Merge branch 'DaleStudy:main' into main

Author: SamTheKorean

3sum/Cyjin-jani.js

@@ -0,0 +1,45 @@
+// ! 풀다가 막혀서 AI의 도움(힌트)을 받아 완성한 코드입니다..
+
+// tc: o(n^2)
+// sc: o(n)
+const threeSum = function (nums) {
+  const answer = [];
+
+  // 먼저 오름차순 정렬하기
+  const sortedArr = nums.sort((a, b) => a - b);
+
+  for (let i = 0; i < sortedArr.length; i++) {
+    if (i > 0 && sortedArr[i] === sortedArr[i - 1]) continue;
+
+    let left = i + 1;
+    let right = sortedArr.length - 1;
+
+    while (left < right) {
+      const sum = sortedArr[i] + sortedArr[left] + sortedArr[right];
+
+      if (sum === 0) {
+        answer.push([sortedArr[i], sortedArr[left], sortedArr[right]]);
+
+        // 중복 처리
+        // left가 가리키는 숫자가 이전 숫자와 똑같다면 계속 패스
+        while (left < right && sortedArr[left] === sortedArr[left + 1]) {
+          left++;
+        }
+        // right가 가리키는 숫자가 이전 숫자와 똑같다면 계속 패스
+        while (left < right && sortedArr[right] === sortedArr[right - 1]) {
+          right--;
+        }
+        // 똑같은 숫자들을 다 건너뛰었으니, 새로운 숫자로 넘어감
+        left++;
+        right--;
+      } else if (sum < 0) {
+        // 0보다 작으면 left를 키움 (오름차순 정렬이기 때문)
+        left++;
+      } else {
+        right--;
+      }
+    }
+  }
+
+  return answer;
+};

3sum/YOOHYOJEONG.py

@@ -0,0 +1,37 @@
+# https://leetcode.com/problems/3sum
+
+class Solution(object):
+    def threeSum(self, nums):
+        nums.sort()
+        result = []
+
+        for i in range(len(nums) - 2):
+
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+
+            left = i + 1
+            right = len(nums) - 1
+
+            while left < right:
+                total = nums[i] + nums[left] + nums[right]
+
+                if total < 0:
+                    left += 1
+
+                elif total > 0:
+                    right -= 1
+
+                else:
+                    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
+
+        return result

3sum/Yu-Won.js

@@ -0,0 +1,40 @@
+/**
+ * 문제: https://leetcode.com/problems/3sum/description/
+ *
+ * 요구사항:
+ * nums: number[]가 주어질 때 3개의 합이 0이되는 배열을 리턴한다.
+ *
+ * * */
+
+const threeSum = (nums) => {
+    let result = [];
+
+    nums.sort((a,b) => a-b);
+
+    for(let i = 0; i <nums.length-2; i++) {
+        if(i > 0 && nums[i] === nums[i-1]) continue;
+
+        if(nums[i] > 0) break;
+
+        let left= i+1;
+        let right = nums.length -1;
+
+        while(left < right) {
+            let 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/dohyeon2.java

@@ -0,0 +1,55 @@
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.List;
+
+class Solution {
+    // TC: O(n^2)
+    // SC: O(n^2)
+    public List<List<Integer>> threeSum(int[] nums) {
+        List<List<Integer>> answer = new ArrayList<List<Integer>>();
+
+        // Sort the array to use two-pointer technique.
+        Arrays.sort(nums);
+
+        // Exclude the last two elements from the loop
+        // since the two pointers are involved in the iteration.
+        for (int i = 0; i < nums.length - 2; i++) {
+            if (i - 1 >= 0 && nums[i] == nums[i - 1]) {
+                // Skip if this number is the same as the previous one,
+                // so that we can avoid duplicate triplets.
+                continue;
+            }
+
+            int left = i + 1;
+            int right = nums.length - 1;
+
+            while (left < right) {
+                int sum = nums[i] + nums[left] + nums[right];
+                if (sum == 0) {
+                    ArrayList<Integer> list = new ArrayList<>(
+                            Arrays.asList(nums[i], nums[left], nums[right]));
+                    answer.add(list);
+
+                    // According to the problem, we need to avoid duplicate triplets.
+                    // Therefore, this loop is needed.
+                    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 answer;
+    }
+}

3sum/gcount85.py

@@ -0,0 +1,54 @@
+"""
+# Intuition
+처음에는 1주차의 Two Sum 문제 풀이를 응용하여, 배열 순회 + 해시 테이블 만들어 값 찾기를 시도했으나
+정렬 + 투포인터 풀이가 더 빠르므로 그렇게 제출했습니다.
+
+# Approach
+nums 배열을 순회하면서 -nums[i]를 합으로 하는 두 수를 나머지 배열 부분에서 찾는다.
+찾을 때는 정렬 & 투포인터를 활용하여 중복을 건너 뛰는 방식으로 속도를 높인다.
+
+
+# Complexity
+- Time complexity: 정렬 + 투포인터 이중 반복으로 O(N^2)
+
+- Space complexity: 정렬 하는데에 O(N) , answer 배열 생성하는데에 O(M)
+"""
+
+
+class Solution:
+    def threeSum(self, nums: list[int]) -> list[list[int]]:
+        nums.sort()  # O(NlogN)
+        n = len(nums)
+        answer = []
+
+        for i in range(n - 2):  # 이중 반복문 O(N^2)
+            # 중복 제거
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+
+            # nums[i]가 0보다 크면 뒤도 다 양수라 종료 가능
+            if nums[i] > 0:
+                break
+
+            left, right = i + 1, n - 1
+
+            while left < right:
+                total = nums[i] + nums[left] + nums[right]
+
+                if total == 0:
+                    answer.append([nums[i], nums[left], nums[right]])
+                    left += 1
+                    right -= 1
+
+                    # left/right 중복 제거
+                    while left < right and nums[left] == nums[left - 1]:
+                        left += 1
+                    while left < right and nums[right] == nums[right + 1]:
+                        right -= 1
+
+                elif total < 0:
+                    left += 1
+                else:
+                    right -= 1
+
+        return answer

3sum/hwi-middle.cpp

@@ -0,0 +1,41 @@
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {
+        vector<vector<int>> res;
+
+        sort(nums.begin(), nums.end());
+
+        for (int i = 0; i < nums.size() && nums[i] <= 0; ++i)
+        {
+            if (i != 0 && nums[i - 1] == nums[i]) 
+            {
+                continue;
+            }
+
+            int l = i + 1;
+            int 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.push_back({nums[i], nums[l++], nums[r--]});
+                    while (l < r && nums[l] == nums[l - 1])
+                    {
+                        ++l;
+                    }
+                }
+            }
+        }
+
+        return res;
+    }
+};

3sum/hyeri0903.py

@@ -0,0 +1,39 @@
+from itertools import combinations
+
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        """
+        time complexity : O(n^2)
+        space complexity : O(1)
+        """
+        answer = []
+        nums.sort()
+        n = len(nums)
+
+        for i in range(n):
+            #skipped if nums[i] == nums[i-1] to avoid duplicate triplets
+            if i > 0 and nums[i] == nums[i-1]:
+                continue
+
+            #search with two pointer
+            left, right = i+1, n-1
+
+            while left < right:
+                total = nums[left] + nums[i] + nums[right]
+                if total == 0:
+                    answer.append([nums[left], nums[i], nums[right]])
+                    
+                    #move the pointers past duplicates
+                    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 answer