Merge branch 'DaleStudy:main' into main

3sum/Chaedie.py

@@ -0,0 +1,59 @@
+"""
+첫번째 풀이 -> 달레의 코드 풀이
+1) sort와 two pointer를 활용한 풀이
+2) has_set 을 활용한 중복 제거
+
+두번째 풀이 -> Neetcode 풀이
+1) sort와 two pointer를 활용한 풀이
+2) while loop 를 활용한 중복 제거
+
+Time: O(n^2) = O(n) * O(n)
+Space: O(n)
+"""
+
+
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        nums.sort()
+        res = set()
+        n = len(nums)
+
+        for i in range(n):
+            l, r = i + 1, n - 1
+            while l < r:
+                summ = nums[i] + nums[l] + nums[r]
+                if summ < 0:
+                    l += 1
+                elif summ > 0:
+                    r -= 1
+                else:
+                    res.add((nums[i], nums[l], nums[r]))
+                    l += 1
+        return list(res)
+
+
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        nums.sort()
+        res = []
+        n = len(nums)
+
+        for i in range(n):
+            l, r = i + 1, n - 1
+
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+
+            while l < r:
+                summ = nums[i] + nums[l] + nums[r]
+                if summ < 0:
+                    l += 1
+                elif summ > 0:
+                    r -= 1
+                else:
+                    res.append([nums[i], nums[l], nums[r]])
+                    l += 1
+                    while nums[l] == nums[l - 1] and l < r:
+                        l += 1
+
+        return res

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/HodaeSsi.py

@@ -0,0 +1,21 @@
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        answerSet = set()
+        nums.sort()
+
+        for i in range(len(nums) - 2):
+            leftIdx = i + 1
+            rightIdx = len(nums) - 1
+            while leftIdx < rightIdx:
+                sum = nums[i] + nums[leftIdx] + nums[rightIdx]
+                if sum < 0:
+                    leftIdx += 1
+                elif sum > 0:
+                    rightIdx -= 1
+                else:
+                    answerSet.add((nums[i], nums[leftIdx], nums[rightIdx]))
+                    leftIdx = leftIdx + 1
+                    rightIdx = rightIdx - 1
+
+        return list(answerSet)
+

3sum/JisooPyo.kt

@@ -0,0 +1,154 @@
+package leetcode_study
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+
+/**
+ * Leetcode
+ * 15. 3Sum
+ * Medium
+ */
+class `3Sum` {
+    /**
+     * 3중 for문으로 풀어봤는데 시간 초과가 되더라고요(당연)
+     * 사실 잘 모르겠어서 Topic과 힌트를 살짝 봤는데 투 포인터가 있길래 이걸 이용해서 풀어보기로 했습니다!
+     *
+     * Runtime: 72 ms(Beats: 60.54 %)
+     * Time Complexity: O(n^2)
+     *
+     * Memory: 56.28 MB(Beats: 49.51 %)
+     * Space Complexity: O(n^2)
+     */
+    fun threeSum(nums: IntArray): List<List<Int>> {
+        val answer = mutableListOf<List<Int>>()
+        // 배열 정렬 - 중복된 경우를 제거하고 효율적으로 탐색하기 위하여
+        nums.sort()
+
+        // nums[i]의 이전 값을 의미합니다.
+        var prev = Integer.MIN_VALUE
+        for (i in nums.indices) {
+            // 이전 값과 동일한 값이라면 스킵하여 중복된 경우를 제거합니다.
+            if (nums[i] == prev) {
+                continue
+            }
+
+            // 투 포인터 알고리즘을 이용하여 다 더하여 0이 되는 경우의 수를 찾습니다.
+            var left = i + 1
+            var right = nums.size - 1
+            while (left < right) {
+
+                if (nums[i] + nums[left] + nums[right] > 0) {           // 합이 0보다 크다면 right를 줄입니다.
+                    // if 내에 있는 while문들은 중복 경우의 수를 피하기 위함입니다.
+                    while (0 <= right - 1 && nums[right - 1] == nums[right]) {
+                        right--
+                    }
+                    right--
+                } else if (nums[i] + nums[left] + nums[right] < 0) {    // 합이 0보다 적다면 left를 높입니다.
+                    while (left + 1 <= nums.size - 1 && nums[left] == nums[left + 1]) {
+                        left++
+                    }
+                    left++
+                } else {        // 합이 0이라면 경우의 수를 추가합니다.
+                    answer.add(listOf(nums[i], nums[left], nums[right]))
+                    while (left + 1 <= nums.size - 1 && nums[left] == nums[left + 1]) {
+                        left++
+                    }
+                    left++
+                    while (0 <= right - 1 && nums[right - 1] == nums[right]) {
+                        right--
+                    }
+                    right--
+                }
+            }
+            prev = nums[i]
+        }
+        return answer
+    }
+
+    /**
+     * 시간 복잡도나 공간 복잡도가 개선되진 않았지만 가독성 측면에서 개선해본 버전입니다.
+     * Runtime: 66 ms(Beats: 65.59 %)
+     * Time Complexity: O(n^2)
+     *
+     * Memory: 56.64 MB(Beats: 43.12 %)
+     * Space Complexity: O(n^2)
+     */
+    fun threeSum2(nums: IntArray): List<List<Int>> {
+        val answer = mutableListOf<List<Int>>()
+        nums.sort()
+
+        // 첫 세 수의 합이 0보다 크거나, 마지막 세 수의 합이 0보다 작으면 불가능
+        val lastIndex = nums.size - 1
+        if (nums[0] + nums[1] + nums[2] > 0 ||
+            nums[lastIndex] + nums[lastIndex - 1] + nums[lastIndex - 2] < 0
+        ) {
+            return emptyList()
+        }
+
+        var prev = nums[0] - 1
+        for (i in nums.indices) {
+            // 조기 종료 조건 추가
+            if (nums[i] > 0) {
+                break
+            }
+            if (nums[i] == prev) {
+                continue
+            }
+            var left = i + 1
+            var right = nums.size - 1
+            while (left < right) {
+                // 중복 로직 제거 및 sum 변수화
+                val sum = nums[i] + nums[left] + nums[right]
+                when {
+                    sum > 0 -> right = skipDuplicates(nums, right, false)
+                    sum < 0 -> left = skipDuplicates(nums, left, true)
+                    else -> {
+                        answer.add(listOf(nums[i], nums[left], nums[right]))
+                        left = skipDuplicates(nums, left, true)
+                        right = skipDuplicates(nums, right, false)
+                    }
+                }
+            }
+            prev = nums[i]
+        }
+        return answer
+    }
+
+    private fun skipDuplicates(nums: IntArray, index: Int, isLeft: Boolean): Int {
+        var current = index
+        return if (isLeft) {
+            while (current + 1 < nums.size && nums[current] == nums[current + 1]) current++
+            current + 1
+        } else {
+            while (0 <= current - 1 && nums[current - 1] == nums[current]) current--
+            current - 1
+        }
+    }
+
+    @Test
+    fun test() {
+        threeSum(intArrayOf(-1, 0, 1, 2, -1, -4)) shouldBe listOf(
+            listOf(-1, -1, 2),
+            listOf(-1, 0, 1)
+        )
+        threeSum(intArrayOf(0, 1, 1)) shouldBe emptyList<Int>()
+        threeSum(intArrayOf(0, 0, 0)) shouldBe listOf(
+            listOf(0, 0, 0)
+        )
+        threeSum(intArrayOf(-2, 0, 0, 2, 2)) shouldBe listOf(
+            listOf(-2, 0, 2)
+        )
+        threeSum2(intArrayOf(-1, 0, 1, 2, -1, -4)) shouldBe listOf(
+            listOf(-1, -1, 2),
+            listOf(-1, 0, 1)
+        )
+        threeSum2(intArrayOf(0, 1, 1)) shouldBe emptyList<Int>()
+        threeSum2(intArrayOf(0, 0, 0)) shouldBe listOf(
+            listOf(0, 0, 0)
+        )
+        threeSum2(intArrayOf(-2, 0, 0, 2, 2)) shouldBe listOf(
+            listOf(-2, 0, 2)
+        )
+    }
+
+}

3sum/KwonNayeon.py

@@ -0,0 +1,42 @@
+"""
+Constraints:
+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) (결과 리스트)
+"""
+
+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:
+                sum = nums[i] + nums[left] + nums[right]
+
+                if sum == 0:
+                    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
+
+                elif sum < 0:
+                    left += 1
+                else:
+                    right -= 1
+
+        return result

3sum/aa601.py

@@ -0,0 +1,27 @@
+# 전체 시간복잡도 : O(n^2), 공간복잡도 : O(n)
+class Solution:
+	def threeSum(self, nums: list[int]) -> list[list[int]]:
+		nums.sort() # 내장함수 sort()의 시간복잡도 O(nlogn)
+		result = [] # 공간복잡도 O(n)
+		# 시간복잡도 O(n)
+		for i in range(len(nums) - 2): 
+			if i > 0 and nums[i] == nums[i - 1]:
+				continue
+			r = len(nums) - 1
+			l = i + 1
+			# i를 기준으로 l과 r을 탐색하는 시간 복잡도 : O(n)
+			while l < r: 
+				if nums[i] + nums[l] + nums[r] < 0:
+					l += 1
+				elif nums[i] + nums[l] + nums[r] > 0:
+					r -= 1
+				else:
+					result.append([nums[i], nums[l], nums[r]])
+					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
+		return result
+