Merge remote-tracking branch 'upstream/main'

Author: chapse57

3sum/KwonNayeon.py

@@ -3,14 +3,35 @@
 1. 3 <= nums.length <= 3000
 2. -10^5 <= nums[i] <= 10^5
 
-Time Complexity:
-    - O(n^2) (정렬은 O(n log n), 이중 반복문은 O(n^2))
-Space Complexity:
-    - O(n) (결과 리스트)
+Time Complexity: O(n^2)
+- 정렬은 O(n log n), 이중 반복문은 O(n^2)
+Space Complexity: O(n)
+- 결과 리스트를 저장하는 데 필요한 공간
+
+풀이 방법:
+- 투 포인터를 활용하여 합이 0이 되는 세 수 조합 찾기
+- 배열 정렬: 투 포인터 사용 + 중복 처리 용이
+- for 루프: 첫 번째 숫자 선택 (len(nums)-2까지)
+  - 중복된 첫 번째 숫자 건너뛰기
+  - left, right 포인터 설정
+- while 루프: 두 포인터가 교차하지 않아야 함
+  - sum = nums[i] + nums[left] + nums[right] 계산
+  - sum == 0: 결과 추가, 중복 건너뛰기, 양쪽 포인터 이동
+  - sum < 0: left 증가 (더 큰 값 필요)
+  - sum > 0: right 감소 (더 작은 값 필요)
+- 최종 결과 반환
 """
+# Brute-force: three nested loops → O(n^3)
+# Optimized: sort + two pointer → O(n^2)
 
 class Solution:
     def threeSum(self, nums: List[int]) -> List[List[int]]:
+        # Step 1: Sort the array
+        # Step 2: Fix one number using for loop
+        # Step 3: Use two pointers to find two other numbers
+        #   - if sum == 0: valid triplet
+        #   - if sum < 0: move left pointer
+        #   - if sum > 0: move right pointer
         nums.sort()
         result = []
 

3sum/PDKhan.cpp

@@ -0,0 +1,36 @@
+class Solution {
+    public:
+        vector<vector<int>> threeSum(vector<int>& nums) {
+            vector<vector<int>> result;
+            sort(nums.begin(), nums.end());
+    
+            for(int i = 0; i < nums.size(); i++){
+                if(i > 0 && nums[i] == nums[i-1])
+                    continue;
+                
+                int left = i + 1;
+                int right = nums.size() - 1;
+    
+                while(left < right){
+                    int sum = nums[i] + nums[left] + nums[right];
+    
+                    if(sum == 0){
+                        result.push_back({nums[i], nums[left], nums[right]});
+                        left++;
+                        right--;
+    
+                        while(left < right && nums[left] == nums[left-1])
+                            left++;
+                    
+                        while(left < right && nums[right] == nums[right+1])
+                            right--;
+                    }else if(sum < 0)
+                        left++;
+                    else
+                        right--;
+                }
+            }
+    
+            return result;
+        }
+    };

3sum/Tessa1217.java

@@ -0,0 +1,63 @@
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+// 정수 배열 nums가 주어질 때 nums[i], nums[j], nums[k]로 이루어진 배열을 반환하시오
+// 반환 배열 조건: i 가 j와 같지 않고, i가 k와 같지 않으며 세 요소의 합이 0인 배열
+class Solution {
+
+    // 시간복잡도: O(n^2)
+    public List<List<Integer>> threeSum(int[] nums) {
+
+        Arrays.sort(nums);
+
+        List<List<Integer>> answer = new ArrayList<>();
+
+        int left = 0;
+        int right = 0;
+        int sum = 0;
+
+        for (int i = 0; i < nums.length - 2 && nums[i] <= 0; i++) {
+
+            // 중복 제거
+            if (i > 0 && nums[i] == nums[i - 1]) {
+                continue;
+            }
+
+            left = i + 1;
+            right = nums.length - 1;
+
+            while (left < right) {
+
+                sum = nums[i] + nums[left] + nums[right];
+                // System.out.println(String.format("%d, %d, %d", i, left, right));
+                // System.out.println(String.format("%d + %d + %d = %d", nums[i], nums[left], nums[right], sum));
+                if (sum < 0) {
+                    left++;
+                    continue;
+                }
+                if (sum > 0) {
+                    right--;
+                    continue;
+                }
+
+                answer.add(List.of(nums[i], nums[left], nums[right]));
+
+                // 중복 제거
+                while (left < right && left + 1 < nums.length && nums[left] == nums[left + 1]) {
+                    left++;
+                }
+                while (left < right && right - 1 >= 0 && nums[right] == nums[right - 1]) {
+                    right--;
+                }
+                left++;
+                right--;
+
+            }
+        }
+
+        return answer;
+    }
+
+}
+

3sum/ayosecu.py

@@ -0,0 +1,52 @@
+from typing import List
+
+class Solution:
+    """
+        - Algorithm
+            - Sort and compares with three pointers: target, left(l), right(r)
+        - Time Complexity: O(n^2), n = len(nums)
+            - sort : O(nlogn)
+            - nested two loops : O(n^2)
+            - O(nlogn + n^2) => O(n^2)
+        - Space Complexity: O(n^2) if result included.
+            - result size : result.append() called in n^2 times (nested two loops)
+    """
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        result = []
+        nums.sort()
+        
+        n = len(nums)
+        for i in range(n - 2):
+            # skip duplicated numbers
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+            
+            target = nums[i]
+            l, r = i + 1, n - 1
+            while l < r:
+                if nums[l] + nums[r] == -target:
+                    result.append([target, nums[l], nums[r]])                   
+                    # skip duplicated numbers
+                    while l < r and nums[l] == nums[l + 1]:
+                        l += 1
+                    while l < r and nums[r] == nums[r - 1]:
+                        r -= 1
+                    l += 1
+                    r -= 1
+                elif nums[l] + nums[r] < -target:
+                    l += 1
+                else:
+                    r -= 1
+        
+        return result
+
+tc = [
+        ([-1,0,1,2,-1,-4], [[-1,-1,2],[-1,0,1]]),
+        ([0,1,1], []),
+        ([0,0,0], [[0,0,0]])
+]
+
+for i, (nums, e) in enumerate(tc, 1):
+    sol = Solution()
+    r = sol.threeSum(nums)
+    print(f"TC {i} is Passed!" if e == r else f"TC {i} is Failed! - Expected: {e}, Result: {r}")

3sum/eunhwa99.java

@@ -2,68 +2,34 @@
 import java.util.Arrays;
 import java.util.List;
 
-/**
- * 문제 풀이
- */
-// -4 -1 -1 0  2  2
-// p1 p2         p3   sum < 0 -> p2 앞으로
-// p1    p2      p3   sum < 0 -> p2 앞으로
-// p1      p2    p3   sum < 0 -> p2 앞으로
-// p1          p2p3   sum = 0 -> p1 앞으로
-//    p1 p2      p3   sum = 0 -> p3 값 다른 게 나올 때까지 이동
-//    p1 p2 p3        sum < 0 -> p2 앞으로 인데, p2 > p3 되므로 p1 앞으로
-//       p1 p2    p3      sum = 0 반복
-
-/**
- * 시간/공간 복잡도
-  */
-// 시간 복잡도 - 순회 횟수: n + (n-1) + (n-2) + .. => O(N^2)
-// 공간 복잡도 - 배열을 정렬하는 데 O(n log n)의 공간 + 결과를 저장하는 answer 리스트는 문제의 요구에 따라 O(k)의 공간 = O(n log n) (배열 정렬을 위한 공간) + O(k) (결과 저장 공간)
-
-class Solution {
-    public List<List<Integer>> threeSum(int[] nums) {
-        Arrays.sort(nums);  // Sort the array first
-        List<List<Integer>> answer = new ArrayList<>();
-
-        for (int pointer1 = 0; pointer1 < nums.length - 2; pointer1++) {
-            // pointer1 의 중복 값 skip
-            if (pointer1 > 0 && nums[pointer1] == nums[pointer1 - 1]) {
-                continue;
-            }
-
-            int pointer2 = pointer1 + 1;  // pointer2 는 pointer1 의 한 칸 앞
-            int pointer3 = nums.length - 1;  // pointer3 는 끝에서 부터
-
-            while (pointer2 < pointer3) {
-                int sum = nums[pointer1] + nums[pointer2] + nums[pointer3];
-
-                if (sum < 0) {
-                    pointer2++;
-                } else if (sum > 0) {
-                    pointer3--;
+// 시간 복잡도: O(n^2) - nums 배열을 정렬하는 데 O(nlogn) 소요, 이후 이중 포인터로 O(n^2)
+// 공간 복잡도: O(1) - 결과 리스트를 제외한 추가 공간 사용 없음
+class Solution{
+    public List<List<Integer>> threeSum(int[] nums){
+        Arrays.sort(nums);
+
+        List<List<Integer>> result = new ArrayList<>();
+
+        for(int i=0;i<nums.length-2;i++){
+            if(i>0 && nums[i] == nums[i-1]) continue; // 중복된 값 건너뛰기
+            int left = i+1;
+            int right = nums.length-1;
+
+            while(left < right){
+                int sum = nums[i] + nums[left] + nums[right];
+                if(sum == 0){
+                    result.add(Arrays.asList(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 {
-                    // sum == 0
-                    answer.add(Arrays.asList(nums[pointer1], nums[pointer2], nums[pointer3]));
-
-                    // pointer2 중복 값 제거
-                    while (pointer2 < pointer3 && nums[pointer2] == nums[pointer2 + 1]) {
-                        pointer2++;
-                    }
-
-                    // pointer3 중복 값 제거
-                    while (pointer2 < pointer3 && nums[pointer3] == nums[pointer3 - 1]) {
-                        pointer3--;
-                    }
-
-                    // 두 값 모두 move
-                    pointer2++;
-                    pointer3--;
+                    right--;
                 }
             }
         }
-
-        return answer;
+        return result;
     }
 }
-
-

3sum/jiji-hoon96.ts

@@ -0,0 +1,71 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ *
+ * 풀이 1
+ *
+ * 이렇게 푸니까 시간복잡도 O(n^3) / 공간복잡도 O(n) 라서 복잡한 예시에는 time limit 이 발생함
+ * 개선해보자..
+ *
+ * function threeSum(nums: number[]): number[][] {
+ *  nums.sort((a, b) => a - b);
+ *     let result = []
+ *     for (let i= 0; i<nums.length; i++){
+ *         for(let j= i+1 ; j <nums.length; j++){
+ *             for (let k = j+1; k<nums.length; k++){
+ *                 if(nums[i]+nums[j]+nums[k]===0){
+ *                     result.push([nums[i], nums[j], nums[k]]);
+ *                 }
+ *             }
+ *         }
+ *     }
+ *
+ *     return Array.from(
+ *         new Set(result.map(item => JSON.stringify(item))),
+ *         str => JSON.parse(str)
+ *     );
+ *     }
+ *
+ *  풀이 2
+ *
+ *  투포인터를 활용해보자.
+ *  아래처럼 문제를 풀게되면 시간복잡도 O(n^2) / 공간복잡도 O(1) 이다.
+ *  시공간 복잡도가 줄긴하지만 메모리 사용량과 큰 숫자를 다룰 때 성능이 매우 좋다!
+ */
+
+
+function threeSum(nums: number[]): number[][] {
+    let result : number[][] = []
+    nums.sort((a, b) => a - b);
+    const n = nums.length;
+
+    for(let first = 0; first<n-2; first++){
+        // 첫번째가 양수면 0이 될 수 없음
+        if(nums[first] > 0) break;
+
+        //중복된 수는 건너뜀
+        if(first > 0 && nums[first]===nums[first-1]) continue;
+
+        let left = first + 1;
+        let right = n-1;
+
+        while(left < right){
+            const sum = nums[first] +nums[left] + nums[right];
+
+            if(sum < 0){
+                left ++
+            }else if(sum > 0){
+                right --;
+            }else{
+                result.push([nums[first],nums[left],nums[right]]);
+                // left, left+1 이 같을 때 중복된 수는 건너뜀
+                while(left < right && nums[left] === nums[left+1]) left++;
+                // right, right+1 이 같을 때 중복된 수는 건너뜀
+                while(left < right && nums[right] === nums[right-1]) right--;
+                left++;
+                right--;
+            }
+        }
+    }
+    return result;
+}

best-time-to-buy-and-sell-stock/soobing.ts

@@ -0,0 +1,14 @@
+function maxProfit(prices: number[]): number {
+  let minPrice = Infinity;
+  let maxProfit = 0;
+  for (let i = 0; i < prices.length; i++) {
+    if (prices[i] < minPrice) {
+      minPrice = prices[i];
+    }
+
+    if (prices[i] - minPrice > maxProfit) {
+      maxProfit = prices[i] - minPrice;
+    }
+  }
+  return maxProfit;
+}

climbing-stairs/PDKhan.cpp

@@ -0,0 +1,20 @@
+class Solution {
+    public:
+        int climbStairs(int n) {
+            if(n < 2)
+                return 1;
+    
+            int curr = 0;
+            int prev1 = 1;
+            int prev2 = 1;
+            
+            for(int i = 2; i <= n; i++){
+                curr = prev1 + prev2;
+                prev2 = prev1;
+                prev1 = curr;
+            }
+    
+            return curr;
+        }
+    };
+