Merge branch 'main' of https://github.com/DaleStudy/leetcode-study

Author: sangbeenmoon

3sum/DaleSeo.rs

@@ -0,0 +1,37 @@
+// TC: O(n^2)
+// SC: O(1)
+impl Solution {
+    pub fn three_sum(mut nums: Vec<i32>) -> Vec<Vec<i32>> {
+        nums.sort_unstable();
+        let n = nums.len();
+        let mut triplets = Vec::new();
+
+        for i in 0..n {
+            if i > 0 && nums[i] == nums[i - 1] {
+                continue;
+            }
+
+            let (mut low, mut high) = (i + 1, n - 1);
+            while low < high {
+                let three_sum = nums[i] + nums[low] + nums[high];
+                if three_sum < 0 {
+                    low += 1;
+                } else if three_sum > 0 {
+                    high -= 1;
+                } else {
+                    triplets.push(vec![nums[i], nums[low], nums[high]]);
+                    low += 1;
+                    high -= 1;
+                    while low < high && nums[low] == nums[low - 1] {
+                        low += 1;
+                    }
+                    while low < high && nums[high] == nums[high + 1] {
+                        high -= 1;
+                    }
+                }
+            }
+        }
+
+        triplets
+    }
+}

3sum/alphaorderly.py

@@ -0,0 +1,37 @@
+class Solution:
+    def threeSum(self, nums: list[int]) -> list[list[int]]:
+        """
+        O(N^2)
+        """
+        cntr = Counter(nums)
+
+        ans = []
+
+        # First case -> [0, 0, 0] Triplet
+        if cntr[0] >= 3:
+            ans.append([0, 0, 0])
+
+        # Second case -> two same numbers + one diff number
+        for k, v in cntr.items():
+            if k == 0:
+                continue
+            if v >= 2 and -(k * 2) in cntr:
+                ans.append([k, k, -(k * 2)])
+
+        s = set(nums)
+        nums = list(s)
+        nums.sort()
+
+        pos = {k: v for v, k in enumerate(nums)}
+        N = len(nums)
+
+        # Third case -> all different numbers
+        for i in range(N - 2):
+            for j in range(i + 1, N - 1):
+                target = -(nums[i] + nums[j])
+                if target in pos:
+                    k = pos[target]
+                    if k > j:
+                        ans.append([nums[i], nums[j], nums[k]])
+
+        return ans

3sum/dolphinflow86.py

@@ -0,0 +1,21 @@
+# 1) Fix one element first, and then treat others as two-sum problem. Use set to get rid of duplicate combination.
+# TC: O(N^2) where N is the length of nums.
+# SC: O(N) where N is the length of nums.
+class Solution:
+    def threeSum(self, nums: list[int]) -> list[list[int]]:
+        answer: Set[tuple[int,int,int]] = set()
+        n = len(nums)
+        nums.sort()
+        
+        for i in range(n-2):
+            if i > 0 and nums[i] == nums[i-1]: continue
+
+            target = -nums[i]            
+            nums_map: Dict[int, int] = {}
+            for j in range(i + 1, n):
+                comp = target - nums[j]
+                if comp in nums_map:
+                    answer.add((nums[i], comp, nums[j]))
+                nums_map[nums[j]] = j
+
+        return [list(triplet) for triplet in answer]

3sum/jaekwang97.java

@@ -0,0 +1,34 @@
+import java.util.*;
+
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        int n = nums.length;
+        Arrays.sort(nums);
+        List<List<Integer>> answers = new ArrayList<>();
+        Set<List<Integer>> answer = new HashSet<>();
+        for(int i = 0 ; i < n ; i++){
+            if (nums[i] > 0) break;
+            if (i > 0 && nums[i] == nums[i-1]) continue;
+            int left = i + 1;
+            int right = n - 1;
+            while(left < right){
+                int sum = nums[left] + nums[right] + nums[i];
+
+                
+                if (sum > 0) right--;
+                else if (sum < 0) left++;
+                else{
+                    answer.add(new ArrayList<>(List.of(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--;
+                }
+            }
+        }
+        
+        answers = new ArrayList<>(answer);
+
+        return answers;
+    }
+}

3sum/yuseok89.py

@@ -0,0 +1,33 @@
+# TC: O(N^2)
+# SC: O(N)
+class Solution:
+    def threeSum(self, nums: list[int]) -> list[list[int]]:
+
+        cnt_dict = Counter(nums)
+        nums_uniq = sorted(cnt_dict.keys())
+        n = len(nums_uniq)
+
+        ret = []
+
+        for num in cnt_dict.keys():
+            if num == 0:
+                if cnt_dict[num] >= 3:
+                    ret.append([0, 0, 0])
+            elif cnt_dict[num] >= 2 and num * 2 * -1 in cnt_dict:
+                ret.append([num, num, num * 2 * -1])
+
+        for idx1, num1 in enumerate(nums_uniq):
+            if num1 > 0:
+                break
+
+            for idx2 in range(idx1 + 1, n):
+                num2 = nums_uniq[idx2]
+                num3 = (num1 + num2) * -1
+
+                if num2 >= num3:
+                    break
+                elif num3 in cnt_dict:
+                    ret.append([num1, num2, num3])
+
+        return ret
+

README.md

@@ -10,7 +10,8 @@
 
 ## 차수
 
-- 7기 (Mar 1, 2025 - Jun 13, 2026): [프로젝트](https://github.com/orgs/DaleStudy/projects/26/views/3), [팀](https://github.com/orgs/DaleStudy/teams/leetcode07)
+- 8기 (Jun 21, 2026 - Oct 3, 2026): [프로젝트](https://github.com/orgs/DaleStudy/projects/29/views/2), [팀](https://github.com/orgs/DaleStudy/teams/leetcode08)
+- 7기 (Mar 1, 2026 - Jun 13, 2026): [프로젝트](https://github.com/orgs/DaleStudy/projects/26/views/3), [팀](https://github.com/orgs/DaleStudy/teams/leetcode07)
 - 6기 (Nov 8, 2025 - Feb 20, 2026): [프로젝트](https://github.com/orgs/DaleStudy/projects/23/views/3), [팀](https://github.com/orgs/DaleStudy/teams/leetcode06)
 - 5기 (Jul 20, 2025 - Nov 1, 2025): [프로젝트](https://github.com/orgs/DaleStudy/projects/16/views/3), [팀](https://github.com/orgs/DaleStudy/teams/leetcode05)
 - 4기 (Mar 30, 2025 - Jul 12, 2025): [프로젝트](https://github.com/orgs/DaleStudy/projects/13/views/3), [팀](https://github.com/orgs/DaleStudy/teams/leetcode04)

climbing-stairs/alphaorderly.py

@@ -0,0 +1,66 @@
+# class Solution:
+#     def climbStairs(self, n: int) -> int:
+#         """
+#             O(N) with additional space
+#         """
+#         if n <= 2:
+#             return n
+
+#         dp = [0] * (n + 1)
+#         dp[1] = 1
+#         dp[2] = 2
+
+#         for i in range(3, n + 1):
+#             dp[i] = dp[i - 1] + dp[i - 2]
+
+#         return dp[-1]
+
+# class Solution:
+#     """
+#         O(N) Found that solution is fibonacci number
+#     """
+#     def climbStairs(self, n: int) -> int:
+#         if n <= 2:
+#             return n
+
+#         p1, p2 = 1, 2
+#         for i in range(3, n + 1):
+#             p1, p2 = p2, p1 + p2
+
+#         return p2
+
+
+# Fibonacci hack
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        """
+            O(Log N)
+        """
+
+        # O(1) operation
+        def mat_mul(a: List[List[int]], b: List[List[int]]) -> List[List[int]]:
+            ans = [[0] * 2 for _ in range(2)]
+
+            for i in range(2):
+                for j in range(2):
+                    for k in range(2):
+                        ans[i][j] += a[i][k] * b[k][j]
+
+            return ans
+
+        # O(Log N) operation
+        def mat_pow(a: List[List[int]], n: int) -> List[List[int]]:
+            if n == 1:
+                return [[1, 1], [1, 0]]
+
+            half = mat_pow(a, n // 2)
+            multed = mat_mul(half, half)
+
+            if n % 2:
+                return mat_mul(multed, [[1, 1], [1, 0]])
+            else:
+                return multed
+
+        ans = mat_pow([[1, 1], [1, 0]], n)
+
+        return ans[0][0]

climbing-stairs/dolphinflow86.py

@@ -0,0 +1,20 @@
+# 1) Recursion with memoization.
+# TC: O(N) where N is the given natural number.
+# SC: O(N) where N is the given natural number.
+class Solution:
+    def climb_rec(self, n: int, step: int, memo: Dict[int, int]):
+        if step > n: return 0
+        if step in memo: return memo[step]
+        if step == n: return 1
+
+        first_way = self.climb_rec(n, step + 1, memo)
+        second_way = self.climb_rec(n, step + 2, memo)
+        memo[step] = first_way + second_way
+        return memo[step]
+        
+
+    def climbStairs(self, n: int) -> int:
+        if n == 1: return 1
+
+        memo = {}
+        return self.climb_rec(n, 1, memo) + self.climb_rec(n, 2, memo)

climbing-stairs/jaekwang97.java

@@ -0,0 +1,16 @@
+class Solution {
+    public int climbStairs(int n) {
+        if (n <= 2) return n;
+
+        int prev = 1;
+        int cur = 2;
+
+        for (int i = 3; i <= n; i++) {
+            int next = prev + cur;
+            prev = cur;
+            cur = next;
+        }
+
+        return cur;
+    }
+}

climbing-stairs/yuseok89.py

@@ -0,0 +1,15 @@
+# TC: O(N)
+# SC: O(1)
+class Solution:
+    def climbStairs(self, n: int) -> int:
+
+        one_down = 1
+        two_down = 0
+
+        for _ in range(1, n):
+            cur = two_down + one_down
+            two_down = one_down
+            one_down = cur
+
+        return two_down + one_down
+