Merge branch 'DaleStudy:main' into main

Author: Chaedie

3sum/EcoFriendlyAppleSu.kt

@@ -0,0 +1,104 @@
+package leetcode_study
+
+/**
+ * 주어진 배열의 세 원소의 합이 0인 경우를 구하는 문제. (세 개의 값의 결과는 중복되지 않음)
+ *
+ * 주어진 조건
+ * 3 <= nums.length <= 3000
+ * -105 <= nums[i] <= 105
+ */
+
+/**
+ * case01. 조합을 사용한 풀이.
+ * 시간 초과 발생 이유
+ * -> 모든 가능한 세 개의 조합을 생성하기 때문에 발생.
+ * 시간 복잡도:
+ * -> 세 개의 조합 생성 과정: O(n * (n-1) * (n-2)) / 3. 최악의 경우 n = 3000, 4.5 억개 조합 생성
+ * -> 세 개의 조합 결과 sorting 과정: O(klogk). k = 3
+ * -> 결과값을 필터링해 합이 0인 배열을 필터하는 과정: O(n)
+ * 나머지 연산이 세 개의 조합 생성 과정에 영향을 받아 계산 횟수 증가.
+ *
+ * 공간 복잡도:
+ * -> 각 조합을 모두 저장: O(n^3)
+ */
+fun threeSumUseCombination(nums: IntArray): List<List<Int>> {
+    // 결과를 담을 Set 자료구조
+    val processResult = mutableSetOf<List<Int>>()
+
+    // 주어진 배열의 크기를 담는 변수
+    val maxNumber = nums.size
+
+    // 조합 배열의 크기
+    val givenSize = 3
+
+    // 나타낼 인덱스를 구하는 배열 초기화
+    val indices = IntArray(givenSize)
+    for (i in 0 until givenSize) {
+        indices[i] = i
+    }
+
+    while (indices[givenSize - 1] < maxNumber) {
+        processResult.add(indices.map { nums[it] }.sorted())
+        var i = givenSize - 1
+
+        while (i >= 0 && indices[i] == i + maxNumber - givenSize) {
+            i--
+        }
+
+        if (i >= 0) {
+            indices[i]++
+            for (j in i + 1 until givenSize) {
+                indices[j] = indices[j-1] + 1
+            }
+        } else break
+    }
+
+    return processResult.filter { it.sum() == 0 }
+}
+
+/**
+ * case02. 투 포인터를 사용한 풀이
+ * 조합을 사용한 풀이와 달리 시간 초과가 발생하지 않음. O(n^3)의 시간 복잡도를 O(n^2)으로 줄임
+ *
+ * 시간 복잡도:
+ * -> 주어진 숫자 배열 오름차순으로 정렬: O(nlogn)
+ * -> 세 개의 숫자를 더하는 로직
+ *      -> 외부 반복문을 통해 주어진 배열 전체 조회: O(n)
+ *      -> 내부 반복문을 통해 start to last index 순회: O(n)
+ *      -> O(n^2)
+ * ∴ O(nlogn) + O(n^2) => O(n^2)
+ *
+ * 공간 복잡도:
+ * -> 주어진 숫자 배열의 정렬을 담는 공간 필요: O(n)
+ */
+fun threeSum(nums: IntArray): List<List<Int>> {
+    val processResult = mutableListOf<List<Int>>()
+    val sortedNums = nums.sorted()
+
+    for (i in sortedNums.indices) {
+        if (i > 0 && sortedNums[i] == sortedNums[i-1]) continue
+
+        var startIndex = i + 1
+        var lastIndex = sortedNums.size - 1
+
+        while (startIndex < lastIndex) {
+            val sum = sortedNums[i] + sortedNums[startIndex] + sortedNums[lastIndex]
+            when {
+                sum == 0 -> {
+                    processResult.add(listOf(sortedNums[i], sortedNums[startIndex], sortedNums[lastIndex]))
+                    while (startIndex < lastIndex && sortedNums[startIndex] == sortedNums[startIndex + 1]) startIndex++
+                    while (startIndex < lastIndex && sortedNums[lastIndex] == sortedNums[lastIndex - 1]) lastIndex--
+                    startIndex++
+                    lastIndex--
+                }
+                sum < 0 -> {
+                    startIndex++
+                }
+                else -> {
+                    lastIndex--
+                }
+            }
+        }
+    }
+    return processResult
+}

3sum/Jeehay28.js

@@ -0,0 +1,86 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+
+
+// Time Complexity: O(n^2)
+// Space Complexity: O(n^2)
+
+var threeSum = function (nums) {
+
+    const sorted = [...nums].sort((a, b) => a - b);
+
+    let result = [];
+
+    // Loop through the array and pick each number as the first number for the triplet
+    for (let i = 0; i < sorted.length - 2; i++) {
+
+        // skip duplicate values for sorted[middle]
+        if(i > 0 && sorted[i - 1] === sorted[i]) {
+            continue;
+        }
+
+        let left = i + 1; // Left pointer starts right after the current middle
+        let right = sorted.length - 1; // Right pointer starts at the last element
+
+        while (left < right) {
+            const sum = sorted[i] + sorted[left] + sorted[right];
+
+            if (sum === 0) {
+                result.push([sorted[left], sorted[i], sorted[right]]);
+
+                // skip duplicates for sorted[left] and sorted[right]
+                while(left < right && sorted[left] === sorted[left + 1]){
+                    left += 1; // Move left pointer to the right to skip duplicate values
+                } 
+
+                while(left < right && sorted[right] === sorted[right - 1]) {
+                    right -= 1; // Move right pointer to the left to skip duplicate values
+                }
+
+                left += 1; 
+                right -= 1;
+
+            } else if (sum > 0) {
+                right -= 1;
+
+            } else {
+                left += 1
+            }
+        }
+    }
+
+     return result;
+  
+};
+
+
+// var threeSum = function (nums) {
+
+// i != j, i != k, and j != k can be interpreted as i < j < k
+
+    // three nested loops
+    // time complexity of O(n³)
+    // Time Limit Exceeded
+
+    // let result = [];
+
+    // 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 str = [nums[i], nums[j], nums[k]].sort((a, b) => a - b).join(",")
+    //                 result.push(str)
+    //             }
+    //         }
+    //     }
+
+    // }
+
+    // result = [... new Set(result)].map(str => str.split(",").map(str => +str))
+
+    // return result;
+    
+// }
+

3sum/YeomChaeeun.ts

@@ -0,0 +1,42 @@
+/**
+ * 세 숫자의 합이 0이 되는 조합 찾기
+ * 알고리즘 복잡도:
+ * - 시간복잡도: O(n^2)
+ * - 공간복잡도: O(1)
+ * @param nums
+ */
+function threeSum(nums: number[]): number[][] {
+    // 정렬
+    nums.sort((a, b) => a - b)
+    let result: number[][] = []
+
+    // 투포인터
+    for (let i = 0; i < nums.length - 2; i++) {
+        if (i > 0 && nums[i] === nums[i - 1]) continue;
+
+        let start = i + 1
+        let end = nums.length - 1
+        const target = -nums[i] // 고정 숫자를 이용
+        // start + end + target === 0 이므로, start + end === -target
+
+        while (start < end) {
+            const sum = nums[start] + nums[end]
+            if (sum === target) {
+                result.push([nums[i], nums[start], nums[end]])
+
+                // 배열 중복 값 건너뛰기
+                while (start < end && nums[start] === nums[start + 1]) start++
+                while (start < end && nums[start] === nums[end - 1]) end--
+
+                // 포인터 이동
+                start++
+                end--
+            } else if (sum < target) {
+                start++
+            } else {
+                end--
+            }
+        }
+    }
+    return result
+}

3sum/gwbaik9717.js

@@ -0,0 +1,38 @@
+// Time complexity: O(n^2)
+// Space complexity: O(n)
+
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function (nums) {
+  const sumsDict = new Set();
+  const sortedNums = nums.toSorted((a, b) => a - b);
+
+  const n = nums.length;
+
+  for (let i = 0; i < n - 2; i++) {
+    let left = i + 1;
+    let right = n - 1;
+    const fixed = sortedNums[i];
+
+    const targetSum = 0 - fixed;
+
+    while (left < right) {
+      const currentSum = sortedNums[left] + sortedNums[right];
+
+      if (currentSum < targetSum) {
+        left++;
+      } else if (currentSum > targetSum) {
+        right--;
+      } else {
+        const key = [fixed, sortedNums[left], sortedNums[right]];
+        sumsDict.add(key.join(","));
+        left++;
+        right--;
+      }
+    }
+  }
+
+  return Array.from(sumsDict).map((nums) => nums.split(",").map(Number));
+};

3sum/jdy8739.js

@@ -0,0 +1,45 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function(nums) {
+    const answer = [];
+
+    const sorted = nums.sort((a, b) => a - b);
+
+    for (let i=0; i<sorted.length; i++) {
+        if (i > 0 && sorted[i] === sorted[i - 1]) {
+            // 위 조건으로 중복 숫자 필터
+            continue;
+        }
+
+        let l = i + 1;
+        let h = sorted.length - 1;
+
+        while (l < h) {
+            const sum = sorted[i] + sorted[l] + sorted[h];
+
+            if (sum === 0) {
+                const arr = [sorted[i], sorted[l], sorted[h]];
+                answer.push(arr);
+
+                // 아래 반복문으로 중복 숫자 필터
+                while (l < h && sorted[l] === sorted[l + 1]) l++;
+                while (l < h && sorted[h] === sorted[h - 1]) h--;
+
+                h--;
+                l++;
+            }
+
+            if (sum > 0) h--;
+            if (sum < 0) l++;
+        }
+    }
+
+    return answer;
+};
+
+// TC: O(n2)
+// SC: O(1)
+
+

3sum/jungsiroo.py

@@ -0,0 +1,41 @@
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        # Naive Solution
+        # Tc : O(n^3) / Sc : O(nC_3)
+        
+        n = len(nums)
+        """
+        for i in range(n-2):
+            for j in range(i+1,n-1):
+                for k in range(j+1, n):
+                    if nums[i]+nums[j]+nums[k] == 0:
+                        ret.add(tuple(sorted([nums[i], nums[j], nums[k]])))
+
+        ret = [x for x in ret]
+        return ret 
+        """
+
+        # Better Solution
+        # two-sum question with fixed num (traversal in for loop)
+        # Tc : O(n^2) / Sc : O(n)
+        ret = []
+        nums.sort()
+
+        for i in range(n):
+            if i>0 and nums[i] == nums[i-1]:
+                continue
+            j, k = i+1, n-1
+
+            while j < k:
+                sum_ = nums[i] + nums[j] + nums[k]
+                if sum_ < 0 : j += 1
+                elif sum_ > 0 : k -= 1
+                else:
+                    ret.append([nums[i], nums[j], nums[k]])
+                    j += 1
+                
+                    while nums[j] == nums[j-1] and j<k:
+                        j += 1
+            
+        return ret
+