Merge branch 'DaleStudy:main' into main

Author: jylee2033

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/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

3sum/junzero741.ts

@@ -0,0 +1,45 @@
+// TC: O(n^2)
+// SC: O(logn)
+function threeSum(nums: number[]): number[][] {
+    
+    nums.sort((a,b) => a-b);
+    const result: number[][] = []
+
+    for(let i = 0 ; i < nums.length; i++) {
+        let left = i+1;
+        let right = nums.length-1;
+
+        while(left < right) {
+           if(i > 0 && nums[i] === nums[i-1]) {
+                break;
+           }
+
+           const sum = nums[i] + nums[left] + nums[right];
+           if(sum > 0) {
+                right--;
+                continue;
+           }
+           if(sum < 0) {
+                left++;
+                continue;
+           }
+           if(sum === 0) {
+                const triplet: number[] = [nums[i], nums[left], nums[right]];
+                result.push(triplet);
+
+                while(left < right && nums[left] === nums[left+1]) {
+                    left++;
+                }
+                while(left < right && nums[right] === nums[right-1]) {
+                    right--;
+                }
+
+                left++;
+                right--;
+           }
+        }
+        
+    }
+
+    return result;
+};

3sum/kangdaia.py

@@ -0,0 +1,49 @@
+class Solution:
+    def threeSum(self, nums: list[int]) -> list[list[int]]:
+        """
+        nums에서 세 숫자를 골라 합이 0이 되는 조합을 구하는 함수
+        세 숫자는 서로 다른 인덱스에 위치해야 함. 중복된 조합은 포함하지 않아야 함.
+
+        방법
+        1. brute force. 세 숫자를 모두 조합하여 합이 0이 되는지 확인. O(n^3) 시간복잡도 -> 너무 오래 걸림!
+        2. 첫번째 값을 고정하고 나머지 두개의 합을 two sum 문제에서 해결한 것 처럼 dict에 저장하여 찾기. O(n^2) 시간복잡도, O(n) 공간복잡도
+            -> 중복된 조합을 걸러내는 과정이 필요함
+        3. 정렬을 해서, 첫번째 값을 고정하고, 나머지 두개의 합이 첫번째 값의 음수가 되는 경우를 찾음 - 포인터 방식.
+            -> O(n^2) 시간복잡도, O(1) 공간복잡도. 2번 방법보다 정렬을 하지 않으니 효율적
+        4. 3번 방법에 시간을 줄일 수 있는 예외 케이스 혹은 조건을 찾아 빠르게 종료하기
+            - 첫번째 값이 양수인 경우, 나머지 두개의 합이 음수가 될 수 없으므로 종료
+            - 첫번째 값이 이전 값과 같은 경우, 중복된 조합이 되니 건너뛰기
+            - append 값을 찾은 후에 j+1, k-1을 하면서 중복된 값이 아닐때까지 이동하기
+
+        Args:
+            nums (list[int]): 정렬되지 않은 정수목록
+
+        Returns:
+            list[list[int]]: 합이 0이 되는 세 숫자의 조합 목록
+        """
+        answer = []
+        s_nums = sorted(nums)
+        n = len(s_nums)
+        for i in range(n - 2):
+            x = s_nums[i]
+            if i > 0 and x == s_nums[i - 1]:
+                continue
+            if x > 0:
+                break
+            j, k = i + 1, n - 1
+            while j < k:
+                y, z = s_nums[j], s_nums[k]
+                total = x + y + z
+                if total == 0:
+                    answer.append([x, y, z])
+                    j += 1
+                    k -= 1
+                    while j < k and s_nums[j] == s_nums[j - 1]:
+                        j += 1
+                    while j < k and s_nums[k] == s_nums[k + 1]:
+                        k -= 1
+                elif total < 0:
+                    j += 1
+                else:
+                    k -= 1
+        return answer

3sum/mrlee7.py

@@ -0,0 +1,34 @@
+from typing import List
+
+
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        result: List[List[int]] = []
+        nums.sort()
+
+        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:
+                    result.append([nums[i], nums[left], nums[right]])
+                    left += 1
+                    right -= 1
+
+                    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 result

3sum/sadie100.ts

@@ -0,0 +1,49 @@
+/*
+배열을 정렬한 뒤 엘리먼트 하나를 고정하고, 해당 엘리먼트보다 큰 범위에서 투 포인터 순회로 합이 -{엘리먼트값} 이 되는 쌍을 찾는 로직을 모든 배열 엘리먼트에 순회하며 적용한다
+
+시간복잡도 : O(N^2)
+=> 엘리먼트 고정 순회 n * 투 포인터 순회 n
+
+공간복잡도 : O(N) 
+=> 정렬된 배열
+*/
+
+function threeSum(nums: number[]): number[][] {
+  const sortedNums = nums.sort((a, b) => a - b)
+  const result = []
+  let beforeIVal
+
+  for (let i = 0; i < nums.length; i++) {
+    const idxVal = sortedNums[i]
+    if (beforeIVal !== undefined && beforeIVal === idxVal) {
+      continue
+    }
+    beforeIVal = idxVal
+    const shouldBe = -idxVal
+    let start = i + 1
+    let end = nums.length - 1
+
+    while (start < end) {
+      const startVal = sortedNums[start]
+      const endVal = sortedNums[end]
+      const value = startVal + endVal
+      if (value === shouldBe) {
+        result.push([idxVal, startVal, endVal])
+        start += 1
+        end -= 1
+        while (startVal === sortedNums[start]) {
+          start += 1
+        }
+        while (endVal === sortedNums[end]) {
+          end -= 1
+        }
+      } else if (value > shouldBe) {
+        end -= 1
+      } else {
+        start += 1
+      }
+    }
+  }
+
+  return result
+}