Merge branch 'DaleStudy:main' into main

Author: chordpli

3sum/Geegong.java

@@ -0,0 +1,82 @@
+import java.util.*;
+
+public class Geegong {
+
+    /**
+     * Time complexity : O(n^2)
+     * space complexity : O(n^2)
+     * @param nums
+     * @return
+     */
+    public List<List<Integer>> threeSum(int[] nums) {
+
+        // 중복되는 값은 없어야 하기에 HashSet 으로 result
+        HashSet<List<Integer>> result = new HashSet<>();
+
+        // Key : 배열 원소 , value : List<String> 인덱스들
+        // elementMap 은 two pointer 의 값을 더한 값에서 0이 되기 위한 요소를 찾기위해 사용될 것임
+        // tc : O(n)
+        Map<Integer, List<Integer>> elementMap = new HashMap<>();
+        for (int index = 0; index<nums.length; index++) {
+            int value = nums[index];
+            if (elementMap.containsKey(value)) {
+                List<Integer> indices = elementMap.get(value);
+                indices.add(index);
+                elementMap.put(value, indices);
+            } else {
+                List<Integer> newIndices = new ArrayList<>();
+                newIndices.add(index);
+                elementMap.put(value, newIndices);
+            }
+        }
+
+        // leftIndex : 0에서 부터 시작하는 index
+        // rightIndex : nums.length - 1에서부터 감소하는 index
+        // leftIndex > rightIndex 되는 순간까지만 for문을 돌 것이다.
+        // tc : O(N^2 / 2)
+        for (int leftIndex=0; leftIndex < nums.length; leftIndex++) {
+            for (int rightIndex=nums.length - 1; rightIndex >= 0; rightIndex--) {
+
+                if (leftIndex >= rightIndex) {
+                    break;
+                }
+
+
+                int leftValue = nums[leftIndex];
+                int rightValue = nums[rightIndex];
+
+                int neededValueToZero = -leftValue - rightValue;
+                if (elementMap.containsKey(neededValueToZero)) {
+                    // elementMap의 value 가 leftIndex, rightIndex 은 아닌지 확인
+
+                    List<Integer> indices = elementMap.get(neededValueToZero);
+                    // zero 를 만들 수 있는 세번쨰 인덱스가 있는지 확인
+                    int thirdIndex = findThirdIndexToBeZero(leftIndex, rightIndex, indices);
+                    if (-1 != thirdIndex) {
+                        List<Integer> newOne = new ArrayList<>();
+                        newOne.add(nums[leftIndex]);
+                        newOne.add(nums[rightIndex]);
+                        newOne.add(nums[thirdIndex]);
+                        result.add(newOne.stream().sorted().toList());
+                    }
+
+                }
+
+            }
+        }
+
+        return result.stream().toList();
+
+    }
+
+    public int findThirdIndexToBeZero(int leftIndex, int rightIndex, List<Integer> indices) {
+        for (int index : indices) {
+            if (index != leftIndex && index != rightIndex) {
+                return index;
+            }
+        }
+
+        return -1;
+    }
+}
+

3sum/bskkimm.py

@@ -0,0 +1,17 @@
+from typing import List
+
+
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        if len(nums) >= 3 and set(nums) == set([0]):
+            return [[0, 0, 0]]
+        triplets = set()
+        for i in range(len(nums) - 2):
+            seen = set()
+            for j in range(i + 1, len(nums)):
+                f = -(nums[i] + nums[j])
+                if f in seen:
+                    triplet = [nums[i], nums[j], f]
+                    triplets.add(tuple(sorted(triplet)))
+                seen.add(nums[j])
+        return list(triplets)

3sum/chrisjune.py

@@ -0,0 +1,25 @@
+class Solution {
+    func threeSum(_ nums: [Int]) -> [[Int]] {
+        let nums = nums.sorted()
+        var answer: Set<[Int]> = []
+        for (index, num) in nums.enumerated() {
+            var leftIndex = index + 1
+            var rightIndex = nums.endIndex - 1
+            while leftIndex < rightIndex {
+                let sum = num + nums[leftIndex] + nums[rightIndex]
+                if sum == 0 {
+                    answer.insert([num, nums[leftIndex], nums[rightIndex]])
+                    leftIndex += 1
+                    rightIndex -= 1
+                } else if sum < 0 {
+                    leftIndex += 1
+                } else if sum > 0 {
+                    rightIndex -= 1
+                }
+            }
+        }
+        
+        return Array(answer)
+    }
+}
+ 

3sum/delight010.swift

@@ -0,0 +1,102 @@
+//1.dfs로 풀기 : 시간초과 남
+
+
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function(nums) {
+    /*
+    arr: 현재 고정 배열을 뜻함. dfs가 돌때마다 변경됨.
+    start: 끝난 index. arr와 마찬가지로 이것은 for문안에서 변경될 예정. 
+    dep: dep은 현재 dfs의 dep+1을 해주면 됨. 
+    */
+    const numsLength = nums.length
+    if(numsLength ==3 && nums.reduce((a,b)=>a+b,0) == 0) return [nums]
+
+    const ret = []
+    const seen = new Set();
+    nums.sort((a, b) => a - b);
+
+    function dfs(arr,start,dep){
+    if(dep == 3) {
+      if(arr.length !==3) return
+      const arrTotal = arr.reduce((a,b)=>a+b,0);
+      if(arrTotal == 0){
+          const string = [...arr].sort((a,b)=>a-b).join(',')
+          if(!seen.has(string)){
+              seen.add(string)
+              ret.push(arr)
+          }
+      }
+        return 
+    }
+    //만약 start가 0이 되면, i를 감소시켜야하고, 새로운 배열을 추가해야한다. 기존의 배열에 넣어주는게 아니다. 
+
+    //끝점을 증가시키면서 진행해야함. 현재 고정 arr에 끝점 그 앞의 idx부터 진행해서 0까지 감소시키면서 dfs를 돌리면 된다. 
+    //idx가 i-1부터이므로, i는 최소 1이어야 가능하다.
+    for(let idx = start; idx<numsLength; idx++){
+        // currArr.push([...arr,nums[idx]])
+        //현재 i에 대한 현재 currArr를 만들어준다. 
+        //만들어준 각 Arr에 대해서, 다시 dfs로 들어가서, 각 배열의 내부의 합이 0인지 확인하고, 
+        //현재 배열에 대한 set에 대해서 중복이 되는 것은 없는지 확인하면서 넣어준다.
+        dfs([...arr,nums[idx]],idx+1,dep+1)
+    }}
+    dfs([],0,0)
+    //마지막에 set으로 triples의 중복을 제거해줘야한다. 
+
+    return ret
+};
+
+/*
+시간복잡도: 
+nums.sort((a, b) => a - b): 배열 정렬에 O(NlogN)
+
+N개 숫자 중 3개 선택하는 조합 수 N(N−1)(N−2)/6
+정확히 알 수는 없지만, 
+
+N^3 이상으로 보임.
+
+공간복잡도 : O(N^3) => seen 때문.
+
+*/
+
+//2. 투포인터로 풀기
+
+/*
+우선 내가 문제에 대한 이해가 틀렸다. 숫자의 순서가 다르다고 하더라도, 같은 숫자의 조합을 가지고 있다면 안된다. 
+값이 원하는 값보다 작으면 오른쪽 값을 옮기고, 크면 왼쪽 값을 옮기는 투포인터 전략을 취해보았다. 
+
+ */
+
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function(nums) {
+  const triplets = []
+  nums.sort((a,b)=>a-b)
+  for(let i =0;i<nums.length -2 ;i++){
+    if (i > 0 && nums[i] === nums[i - 1]) continue;
+  	let low = i+1
+   	,high = nums.length -1
+    
+    while(low < high){
+     	const three_sum = nums[i] + nums[low] + nums[high]
+        if(three_sum<0){
+        	low +=1
+        }
+      	else if(three_sum >0){
+        	high -=1
+        }
+		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 = low+1
+            high = high -1                 
+        }
+    }
+  }
+  return triplets
+};

3sum/grapefruitgreentealoe.js

@@ -1,5 +1,64 @@
-# O(n^2) time, O(n) space
+"""
+https://leetcode.com/problems/3sum/
+
+문제 설명:
+정렬되지 않은 정수 배열 nums가 주어질 때, 
+세 수의 합이 0이 되는 모든 유니크한 triplet을 찾는 문제.
+
+조건:
+- 중복 조합은 허용되지 않음.
+- 예: [-1, 0, 1]과 [0, -1, 1]은 같은 조합이므로 하나만 포함.
+
+풀이 전략:
+1. 배열을 정렬한다.
+2. 첫 번째 수를 고정한 뒤, 나머지 두 수를 투포인터로 탐색한다.
+   - 합이 0보다 작으면 left를 증가
+   - 합이 0보다 크면 right를 감소
+   - 합이 0이면 정답에 추가, 중복 방지 처리도 함께 수행
+
+TC: O(n^2), 정렬 O(n log n) + 투포인터 O(n^2)
+SC: O(1), 출력 공간 result 제외
+"""
+
+from typing import List
+
+
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        nums.sort()
+        result = []
+
+        for i in range(len(nums) - 2):
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue  # 중복 제거
+
+            left, right = i + 1, 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가 여러 개 있다면, 중복 건너뜀
+                    while left < right and nums[left] == nums[left + 1]:
+                        left += 1
+                    # 같은 값을 가진 right가 여러 개 있다면, 중복 건너뜀
+                    while left < right and nums[right] == nums[right - 1]:
+                        right -= 1
+                    left += 1
+                    right -= 1
+                # 총합이 0보다 작으면, 더 큰 수가 필요하니까 left를 오른쪽으로 이동
+                elif total < 0:
+                    left += 1
+                # 총합이 0보다 크면, 더 작은 수가 필요하니까 right를 왼쪽으로 이동
+                else:
+                    right -= 1
 
+        return result
+
+
+
+# O(n^2) time, O(n) space
 class Solution:
     def threeSum(self, nums: List[int]) -> List[List[int]]:
         triplets = set()

3sum/hi-rachel.py

@@ -0,0 +1,33 @@
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        nums.sort()  # 배열 정렬해서 중복 처리와 투 포인터에 유리하게 만듦
+        n = len(nums)
+        answer = []
+
+        for i in range(n - 2):
+            # i가 0이 아니면서 이전 값과 같으면 중복 방지를 위해 건너뜀
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+
+            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와 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
+                elif total < 0:
+                    left += 1
+                else:
+                    right -= 1
+
+        return answer

3sum/hj4645.py

@@ -0,0 +1,32 @@
+/*
+Time Complexity : O(n^2)
+Space Complexity : O(1)
+*/
+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 low = i + 1;
+            int high = nums.length - 1;
+            while (low < high) {
+                int threeSum = nums[i] + nums[low] + nums[high];
+                if (threeSum < 0) {
+                    low = low + 1;
+                } else if (threeSum > 0) {
+                    high = high - 1;
+                } else {
+                    result.add(Arrays.asList(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 = low + 1;
+                    high = high - 1;
+                }
+             }
+        }
+
+        return result;
+    }
+}

3sum/hoyeongkwak.java

@@ -0,0 +1,28 @@
+class Solution:
+    """
+        1. 3 way for문으로 돌아가면서 0인 합을 찾는 방법
+            - O(n^3)으로 시간초과
+        2. 투포인터
+            - 정렬 후 투포인터를 이용하여 중복 제거와 최적화를 동시에 수행
+            - O(n^2)
+        공간 복잡도는 둘다 O(1)
+    """
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        result = set()
+        nums.sort()
+
+        for i in range(len(nums)):            
+            left, right = i + 1, len(nums) - 1
+            while left < right:
+                total = nums[i] + nums[left] + nums[right]
+
+                if total == 0:
+                    result.add((nums[i], nums[left], nums[right]))
+                    left += 1
+                    right -= 1
+                elif total < 0:
+                    left += 1
+                else:
+                    right -= 1
+
+        return list(result)