Merge branch 'DaleStudy:main' into main

8804who · web-flow · commit cec46671b6b3 · 2025-11-21T23:56:52.000+09:00
diff --git a/3sum/daiyongg-kim.py b/3sum/daiyongg-kim.py
@@ -0,0 +1,36 @@
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        nums.sort()
+
+        result = []
+        n = len(nums)
+
+        for i in range(n - 2):
+            
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+            
+            left = i + 1  
+            right = n - 1 
+            while left < right:
+                current_sum = nums[i] + nums[left] + nums[right]
+
+                if current_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 current_sum < 0:
+                    left += 1
+                
+                else: 
+                    right -= 1
+            
+        return result
diff --git a/3sum/ys-han00.cpp b/3sum/ys-han00.cpp
@@ -0,0 +1,75 @@
+// class Solution {
+// public:
+//     vector<vector<int>> threeSum(vector<int>& nums) {
+//         set<vector<int>> ans;
+//         map<int, int> counter; // {num : cnt}
+//         vector<int> targets;
+//         int target, left, right;
+        
+//         for(int i = 0; i < nums.size(); i++)
+//             counter[nums[i]]++;
+        
+//         for(auto iter : counter)
+//             targets.push_back(iter.first);
+
+//         for(int i = 0; i < targets.size(); i++) {
+//             target = -1 * targets[i];
+            
+//             vector<int> new_nums;
+//             counter[targets[i]]--;
+//             for(auto iter : counter) {
+//                 for(int j = 0; j < iter.second; j++)
+//                     new_nums.push_back(iter.first);
+//             }
+//             left = 0; right = new_nums.size() - 1;
+//             while(left < right) {
+//                 int sum = new_nums[left] + new_nums[right];
+//                 if(sum == target && targets[i] <= new_nums[left] && new_nums[left] <= new_nums[right])
+//                     ans.insert(vector<int>({targets[i], new_nums[left], new_nums[right]}));
+            
+//                 if(sum < target)
+//                     left++;
+//                 else
+//                     right--;
+//             }
+//             counter[targets[i]]++;
+//         }
+        
+//         return vector<vector<int>> (ans.begin(), ans.end());
+//     }
+// };
+
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {
+        vector<vector<int>> ans;
+        int left, right, sum;
+
+        sort(nums.begin(), nums.end());
+
+        for(int i = 0; i < nums.size(); i++) {
+            if(i > 0 && nums[i] == nums[i - 1])
+                continue;
+
+            left = i + 1; right = nums.size() - 1;
+            while(left < right) {
+                sum = nums[i] + nums[left] + nums[right];
+                if(sum == 0) {
+                    ans.push_back(vector<int> ({nums[i], nums[left], nums[right]}));
+                    left++; right--;
+                    while(left < right && nums[left] == nums[left - 1])
+                        left++;
+                    while(left < right && nums[right] == nums[right + 1])
+                        right--;
+                }
+                else if(sum < 0)
+                    left++;
+                else if(sum > 0)
+                    right--;
+            }
+        }
+
+        return ans;
+    }
+};
+
diff --git a/climbing-stairs/YuuuuuuYu.java b/climbing-stairs/YuuuuuuYu.java
@@ -0,0 +1,26 @@
+/**
+ * Runtime: 0ms
+ * Time Complexity: O(n)
+ *
+ * Memory: 42.18MB
+ * Space Complexity: O(n)
+ *
+ * Approach: DP를 이용한 점화식 활용
+ * - n번째 계단에 도달하는 방법은 (n-1)번째 계단에서 한 칸 올라오는 방법과
+ *                          (n-2)번째 계단에서 두 칸 올라오는 방법의 합과 같음
+ */
+class Solution {
+    public int climbStairs(int n) {
+        if (n == 1) return 1;
+        else if (n == 2) return 2;
+
+        int[] dp = new int[n+1];
+        dp[1] = 1;
+        dp[2] = 2;
+        for (int i=3; i<dp.length; i++) {
+            dp[i] = dp[i-1] + dp[i-2];
+        }
+
+        return dp[n];
+    }
+}
diff --git a/climbing-stairs/daiyongg-kim.py b/climbing-stairs/daiyongg-kim.py
@@ -0,0 +1,13 @@
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        if n == 1:
+            return 1
+        
+        prev, curr = 1, 2 
+
+        for i in range(3, n+1):
+            next = prev + curr
+            prev = curr
+            curr = next
+        
+        return curr
diff --git a/climbing-stairs/ys-han00.cpp b/climbing-stairs/ys-han00.cpp
@@ -0,0 +1,18 @@
+class Solution {
+public:
+    int climbStairs(int n) {
+        vector<int> fibo(46, 0);
+        
+        fibo[1] = 1;
+        fibo[2] = 2;
+        
+        if(n <= 2)
+            return fibo[n];
+
+        for(int i = 3; i <= n; i++)
+            fibo[i] = fibo[i - 1] + fibo[i - 2];
+        
+        return fibo[n];
+    }
+};
+
diff --git a/linked-list-cycle/DaleSeo.rs b/linked-list-cycle/DaleSeo.rs
@@ -0,0 +1,28 @@
+// Definition for singly-linked list.
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct ListNode {
+    pub val: i32,
+    pub next: Option<Box<ListNode>>,
+}
+
+// TC: O(n)
+// SC: O(1)
+impl Solution {
+    pub fn has_cycle(head: Option<Box<ListNode>>) -> bool {
+        let mut slow = &head;
+        let mut fast = &head;
+
+        while fast.is_some() && fast.as_ref().unwrap().next.is_some() {
+            slow = &slow.as_ref().unwrap().next;
+            fast = &fast.as_ref().unwrap().next.as_ref().unwrap().next;
+
+            if slow.as_ref().map(|node| node.as_ref() as *const _)
+                == fast.as_ref().map(|node| node.as_ref() as *const _)
+            {
+                return true;
+            }
+        }
+
+        false
+    }
+}
diff --git a/product-of-array-except-self/daiyongg-kim.py b/product-of-array-except-self/daiyongg-kim.py
@@ -0,0 +1,20 @@
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        
+        size = len(nums)
+
+        #initialize array as 1 
+        result = [1] * size
+
+        left_pass = 1
+
+        for i in range(size):A
+            result[i] *= left_pass
+            left_pass *= nums[i]
+
+        right_pass = 1
+        for i in range(size-1, -1, -1):
+            result[i] *= right_pass
+            right_pass *= nums[i]
+
+        return result
diff --git a/product-of-array-except-self/ys-han00.cpp b/product-of-array-except-self/ys-han00.cpp
@@ -0,0 +1,72 @@
+// class Solution {
+// public:
+//     vector<int> productExceptSelf(vector<int>& nums) {
+//         int mul = 1, zero_cnt = 0;
+
+//         for(int i = 0; i < nums.size(); i++) {
+//             if(nums[i] != 0)
+//                 mul *= nums[i];
+//             else
+//                 zero_cnt++;
+//         }
+
+//         vector<int> ans = vector<int>(nums.size(), 0);
+                
+//         if(zero_cnt == 1) {
+//             for(int i = 0; i < nums.size(); i++) {
+//                 if(nums[i] == 0) {
+//                     ans[i] = mul;
+//                     break;
+//                 }
+//             }
+//         } else if(zero_cnt == 0) {
+//             for(int i = 0; i < nums.size(); i++)
+//                 ans[i] = mul / nums[i];
+//         }
+
+//         return ans;
+//     }
+// };
+
+// class Solution {
+// public:
+//     vector<int> productExceptSelf(vector<int>& nums) {
+//         int mul = 1, zero_cnt = 0;
+//         vector<int> prefix(nums.size(), 0), postfix(nums.size(), 0);
+
+//         prefix[0] = 1;
+//         for(int i = 1; i < nums.size(); i++)
+//             prefix[i] = nums[i - 1] * prefix[i - 1];
+
+//         postfix[nums.size() - 1] = 1;
+//         for(int i = nums.size() - 2; i >= 0; i--)
+//             postfix[i] = nums[i + 1] * postfix[i + 1];
+
+//         vector<int> ans = vector<int>(nums.size(), 0);
+//         for(int i = 0; i < nums.size(); i++)
+//             ans[i] = postfix[i] * prefix[i];
+
+//         return ans;
+//     }
+// };
+
+class Solution {
+public:
+    vector<int> productExceptSelf(vector<int>& nums) {
+        vector<int> ans(nums.size(), 1);
+        int before = 1, after = 1;
+
+        for(int i = 0; i < nums.size() - 1; i++) {
+            before *= nums[i];
+            ans[i + 1] *= before;
+        }
+
+        for(int i = nums.size() - 1; i > 0; i--) {
+            after *= nums[i];
+            ans[i - 1] *= after;
+        }
+
+        return ans;
+    }
+};
+
diff --git a/valid-anagram/YuuuuuuYu.java b/valid-anagram/YuuuuuuYu.java
@@ -0,0 +1,33 @@
+/**
+ * Runtime: 2ms
+ * Time Complexity: O(n)
+ *
+ * Memory: 44.56MB
+ * Space Complexity: O(1)
+ *
+ * Approach: a~z 알파벳 개수 배열을 사용하여 짝을 이루는지 검사
+ * - 알파벳 개수가 똑같다면 +- 했을 때 0이 됨
+ */
+class Solution {
+    public boolean isAnagram(String s, String t) {
+        if (s.length() != t.length()) return false;
+
+        int[] checkedArr = new int[26];
+        for (char element: s.toCharArray()) {
+            int index = (int)element - 'a';
+            checkedArr[index]++;
+        }
+
+        for (char element: t.toCharArray()) {
+            int index = (int)element - 'a';
+            checkedArr[index]--;
+        }
+
+        for (int alphabet: checkedArr) {
+            if (alphabet != 0)
+                return false;
+        }
+
+        return true;
+    }
+}
diff --git a/valid-anagram/daiyongg-kim.py b/valid-anagram/daiyongg-kim.py
@@ -0,0 +1,44 @@
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        first = {}
+        second = {}
+
+        for c in s:
+            if c in first:
+                first[c] += 1
+            else:
+                first[c] = 1
+        
+        for c in t:
+            if c in second:
+                second[c] += 1
+            else:
+                second[c] = 1
+        
+        return first == second
+
+
+# class Solution:
+#     def isAnagram(self, s: str, t: str) -> bool:
+#         first = {}
+
+#         if len(s) != len(t):
+#             return False
+
+#         for i in range(len(s)):
+#             if s[i] in first:
+#                 first[s[i]] += 1
+#             else:
+#                 first[s[i]] = 1
+
+#         for i in range(len(t)):
+#             if t[i] in first:
+#                 first[t[i]] -= 1
+#             else:
+#                 return False
+
+#         for i in first.values():
+#             if i != 0:
+#                 return False
+
+#         return True
diff --git a/valid-anagram/ys-han00.cpp b/valid-anagram/ys-han00.cpp
diff --git a/validate-binary-search-tree/daiyongg-kim.py b/validate-binary-search-tree/daiyongg-kim.py
diff --git a/validate-binary-search-tree/ys-han00.cpp b/validate-binary-search-tree/ys-han00.cpp
