Merge branch 'DaleStudy:main' into main

Author: limlimjo

3sum/GangBean.java

@@ -0,0 +1,48 @@
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        /**
+            1. understanding
+            - integer array nums, find the whole combination of 3 nums, and the sum of the 3 nums equal to 0. And don't allow reusing same indiced number(but can duplicate in value)
+            2. solve strategy
+            - brute force 
+                - in every combination, validate sum of the nums equal to 0
+                - but it can take O(N^3) times where N is the length of input array, and given that the N can be 3000 at most(3 * 10^3), time can be 27 * 10^9, which takes too long...
+            - sort and two pointers
+                - sort nums in ascending order, so move the left pointer to right means the sum of window is getting bigger.
+                - and mid pointer set to left + 1 index
+                - if sum of pointers is less than 0, then move mid pointer to right, until the sum is bigger than 0, and while processing them, if the sum of pointers is 0, then add the combination to the return list.
+                - [-4, -1, -1, 0, 1, 2]: 
+            
+            3. complexity
+                - time: O(N^2) -> each left pointer, you can search at most N-1, and left pointer's range is [0, N-1), so the max length is N-1 for left index pointer.
+                - space: O(1) -> no extra space is needed
+        */
+        // 0. assign return variable Set
+        Set<List<Integer>> answer = new HashSet<>();
+
+        // 1. sort the num array in ascending order
+        Arrays.sort(nums); // O(NlogN)
+        // Arrays.stream(nums).forEach(System.out::println);
+
+        // 3. move the mid pointer from left to right to find the combination of which's sum is 0, and if the sum is over 0, and then move right pointer to the left. else if the sum is under 0, then move left pointer to right direction.
+        for (int left = 0; left < nums.length - 1; left++) {
+            int mid = left + 1;
+            int right = nums.length - 1;
+            while (mid < right) {
+                // System.out.println(String.format("%d,%d,%d", nums[left], nums[mid], nums[right]));
+                int sum = nums[left] + nums[mid] + nums[right];
+                if (sum > 0) {
+                    right--;
+                } else if (sum == 0) {
+                    answer.add(List.of(nums[left], nums[mid], nums[right]));
+                    right--;
+                } else {
+                    mid++;
+                }
+            }
+        }
+
+        return new ArrayList<>(answer);
+    }
+}
+

3sum/Gotprgmer.java

@@ -0,0 +1,37 @@
+// 이전에 투포인터를 활용하여 시도했지만 중복된 값들을 처리하는데 어려움이 있었습니다.
+// 그래서 해답을 보았고 새로운 방법으로 풀어보았습니다.
+// 서로 다른 i와 j 인덱스를 2중 for문으로 진행하면서
+// i와 j사이 수들을 set으로 관리합니다.
+// set에 -nums[i]-nums[j]가 존재하면 결과 리스트에 추가합니다.
+// 시간복잡도 : O(N^2)
+// 공간복잡도 : O(N)
+class SolutionGotprgmer {
+    public List<List<Integer>> threeSum(int[] nums) {
+        // 결과를 저장할 리스트
+        List<List<Integer>> result = new ArrayList<>();
+        Set<Integer> set;
+        Set<List<Integer>> resultSet = new HashSet<>();
+        List<Integer> numList;
+
+
+        // 리스트 정렬
+        Arrays.sort(nums);
+        for(int i=0;i<nums.length-2;i++){
+            if (i > 0 && nums[i - 1] == nums[i]) continue;
+
+            set = new HashSet<>();
+            for(int j=i+1;j<nums.length;j++){
+                int checkNum = nums[i]+nums[j];
+                if(set.contains(-checkNum)){
+                    numList = new ArrayList<>(Arrays.asList(nums[i], -checkNum, nums[j]));
+                    if(!resultSet.contains(numList)){
+                        result.add(numList);
+                        resultSet.add(numList);
+                    }
+                }
+                set.add(nums[j]);
+            }
+        }
+        return result;
+    }
+}

3sum/dalpang81.java

@@ -0,0 +1,47 @@
+/*
+* 시간복잡도 : O(N^2)
+* 공간복잡도 : O(1)
+* */
+import java.util.*;
+
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        List<List<Integer>> result = new ArrayList<>();
+        Arrays.sort(nums);
+
+        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)
+                {
+                    // 합이 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
+                    right--;
+
+            }
+        }
+        return result;
+    }
+}

3sum/eunhwa99.java

@@ -0,0 +1,69 @@
+import java.util.ArrayList;
+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--;
+                } 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--;
+                }
+            }
+        }
+
+        return answer;
+    }
+}
+
+

3sum/heypaprika.py

@@ -0,0 +1,30 @@
+# 2Sum을 활용한 풀이
+# Note : 정렬 후 푸는 것이 더 직관적이고, 빠름
+
+"""
+복잡도 : 예상 -> 예상한 이유
+
+시간 복잡도 : O(n^2) -> nums 배열 2중 for문
+공간 복잡도 : O(n) -> 최악의 경우 nums 배열 길이만큼의 딕셔너리 생성
+"""
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        ans_list = set()
+        added_pair = {}
+        for target_i, target_number in enumerate(nums):
+            cur_ans_list = []
+            num_dict = {}
+            if target_number in added_pair:
+                continue
+
+            for i in range(target_i + 1, len(nums)):
+                num_A = nums[i]
+                num_B = - target_number - num_A
+                if num_B in num_dict:
+                    cur_ans_list.append(sorted([target_number, num_A, num_B]))
+                    added_pair[target_number] = num_A
+                num_dict[num_A] = 1
+            for item in cur_ans_list:
+                ans_list.add(tuple(item))
+        return list(ans_list)
+

3sum/higeuni.js

@@ -0,0 +1,43 @@
+// complexity
+// time: O(n^2)
+// - sort: O(n log n)
+// - for loop: O(n)
+// - while loop: O(n)
+// space: O(n)
+// - sortedNums: O(n)
+// - else : O(1)
+
+var threeSum = function(nums) {
+  const sortedNums = nums.sort((a, b) => a - b)
+  const lengthOfArray = nums.length;
+  const answer = [];
+
+  for(let i = 0; i < lengthOfArray; i++ ) {
+      if (i > 0 && nums[i] === nums[i - 1]) continue;
+      const target = (-1) * sortedNums[i];
+
+      let left = i + 1;
+      let right = lengthOfArray - 1;
+
+      while(left < right) {
+          const sumOfLeftAndRight = sortedNums[left] + sortedNums[right];
+          const diff = sumOfLeftAndRight - target;
+
+          if( diff > 0 ){
+              right -= 1;
+          } else if ( diff < 0 ){
+              left += 1
+          } else {
+              answer.push([sortedNums[i], sortedNums[left], sortedNums[right]]);
+              // 중복되는 부분을 처리하는 과정에서 계속 fail되어 찾아보니 이렇게 해야 통과되었다.
+              while(left < right && sortedNums[left] === sortedNums[left + 1]) left ++;
+              while(left < right && sortedNums[right] === sortedNums[right - 1]) right --;
+              
+              left++;
+              right--;
+          }
+      }
+  }
+  return answer
+};
+

3sum/minji-go.java

@@ -0,0 +1,41 @@
+/*
+    Problem: https://leetcode.com/problems/3sum/
+    Description: return all the triplets (i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0)
+    Concept: Array, Two Pointers, Sorting
+    Time Complexity: O(N²), Runtime 70ms
+    Space Complexity: O(N), Memory 51.63MB
+*/
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        Map<Integer, Integer> number = new HashMap<>();
+        for(int i=0; i<nums.length; i++) {
+            number.put(nums[i], number.getOrDefault(nums[i], 0)+1);
+        }
+
+        Arrays.sort(nums);
+        Set<List<Integer>> set = new HashSet<>();
+        List<List<Integer>> triplets = new ArrayList<>();
+        List<Integer> lastTriplet = null;
+        for(int i=0; i<nums.length-1; i++) {
+            if(i>0 && nums[i]==nums[i-1]) continue;
+
+            for(int j=i+1; j<nums.length; j++){
+                if(j>i+1 && nums[j]==nums[j-1]) continue;
+
+                int target = -(nums[i]+nums[j]);
+                if(nums[j]>target) continue;
+
+                int count = number.getOrDefault(target,0);
+                if(nums[i]==target) count--;
+                if(nums[j]==target) count--;
+                if(count<=0) continue;
+
+                List<Integer> triplet = List.of(nums[i], nums[j], target);
+                if(triplet.equals(lastTriplet)) continue;
+                lastTriplet = triplet;
+                triplets.add(triplet);
+            }
+        }
+        return triplets;
+    }
+}

3sum/paragon0107.java

@@ -0,0 +1,28 @@
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        Set<List<Integer>> set = new HashSet<>();
+        Arrays.sort(nums);
+        for (int i = 0; i < nums.length-2; i++) {
+            int start = i + 1;
+            int end = nums.length - 1;
+            while (start < end) {
+                int sum = nums[i] + nums[start] + nums[end];
+                if (sum < 0 ) {
+                    start++;
+                } else if (sum > 0) {
+                    end--;
+                }else {
+                    set.add(Arrays.asList(nums[i], nums[start], nums[end]));
+                    start++;
+                    end--;
+                }
+            }
+        }
+        return set.stream().toList();
+    }
+}

3sum/taewanseoul.ts

@@ -0,0 +1,45 @@
+/**
+ * 15. 3Sum
+ * Given an integer array nums, return all the triplets [nums[i], nums[j], nums[k]] such that i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0.
+ * Notice that the solution set must not contain duplicate triplets.
+ *
+ * https://leetcode.com/problems/3sum/description/
+ */
+function threeSum(nums: number[]): number[][] {
+  nums.sort((a, b) => a - b);
+  const triplets: number[][] = [];
+
+  for (let i = 0; i < nums.length - 2; i++) {
+    if (nums[i] > 0 || nums[i] === nums[i - 1]) {
+      continue;
+    }
+
+    let low = i + 1;
+    let high = nums.length - 1;
+
+    while (low < high) {
+      const sum = nums[i] + nums[low] + nums[high];
+      if (sum < 0) {
+        low++;
+      } else if (sum > 0) {
+        high--;
+      } else {
+        triplets.push([nums[i], nums[low], nums[high]]);
+
+        while (low < high && nums[low] === nums[low + 1]) {
+          low++;
+        }
+        while (low < high && nums[high] === nums[high - 1]) {
+          high--;
+        }
+        low++;
+        high--;
+      }
+    }
+  }
+
+  return triplets;
+}
+
+// O(n^2) time
+// O(n) space