Merge branch 'DaleStudy:main' into main

Author: togo26

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/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/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
+

contains-duplicate/Chanz82.py

@@ -0,0 +1,10 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        hashmap = dict()
+        sorted(nums)
+        for num in nums:
+            if hashmap.get(num, False) == True: 
+                return True
+            else :
+                hashmap[num] = True
+        return False

contains-duplicate/ICE0208.py

@@ -0,0 +1,3 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        return len(set(nums)) != len(nums)

contains-duplicate/JeonJe.java

@@ -0,0 +1,16 @@
+import java.util.*;
+
+// TC: O(n)
+// SC: O(n)
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        Set<Integer> set = new HashSet<>();
+        for (int num : nums) {
+            if (set.contains(num)) {
+                return true;
+            }
+            set.add(num);
+        }
+        return false;
+    }
+}