Merge branch 'DaleStudy:main' into main

Author: sadie100

3sum/Yu-Won.js

@@ -0,0 +1,40 @@
+/**
+ * 문제: https://leetcode.com/problems/3sum/description/
+ *
+ * 요구사항:
+ * nums: number[]가 주어질 때 3개의 합이 0이되는 배열을 리턴한다.
+ *
+ * * */
+
+const threeSum = (nums) => {
+    let result = [];
+
+    nums.sort((a,b) => a-b);
+
+    for(let i = 0; i <nums.length-2; i++) {
+        if(i > 0 && nums[i] === nums[i-1]) continue;
+
+        if(nums[i] > 0) break;
+
+        let left= i+1;
+        let right = nums.length -1;
+
+        while(left < right) {
+            let sum = nums[i] + nums[left] + nums[right];
+
+            if(sum === 0) {
+                result.push([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--;
+            } else if (sum <0) {
+                left++;
+            } else {
+                right--;
+            }
+        }
+    }
+    return result;
+}

3sum/gcount85.py

@@ -0,0 +1,54 @@
+"""
+# Intuition
+처음에는 1주차의 Two Sum 문제 풀이를 응용하여, 배열 순회 + 해시 테이블 만들어 값 찾기를 시도했으나
+정렬 + 투포인터 풀이가 더 빠르므로 그렇게 제출했습니다.
+
+# Approach
+nums 배열을 순회하면서 -nums[i]를 합으로 하는 두 수를 나머지 배열 부분에서 찾는다.
+찾을 때는 정렬 & 투포인터를 활용하여 중복을 건너 뛰는 방식으로 속도를 높인다.
+
+
+# Complexity
+- Time complexity: 정렬 + 투포인터 이중 반복으로 O(N^2)
+
+- Space complexity: 정렬 하는데에 O(N) , answer 배열 생성하는데에 O(M)
+"""
+
+
+class Solution:
+    def threeSum(self, nums: list[int]) -> list[list[int]]:
+        nums.sort()  # O(NlogN)
+        n = len(nums)
+        answer = []
+
+        for i in range(n - 2):  # 이중 반복문 O(N^2)
+            # 중복 제거
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+
+            # nums[i]가 0보다 크면 뒤도 다 양수라 종료 가능
+            if nums[i] > 0:
+                break
+
+            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 += 1
+                    right -= 1
+
+                    # left/right 중복 제거
+                    while left < right and nums[left] == nums[left - 1]:
+                        left += 1
+                    while left < right and nums[right] == nums[right + 1]:
+                        right -= 1
+
+                elif total < 0:
+                    left += 1
+                else:
+                    right -= 1
+
+        return answer

3sum/hwi-middle.cpp

@@ -0,0 +1,41 @@
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {
+        vector<vector<int>> res;
+
+        sort(nums.begin(), nums.end());
+
+        for (int i = 0; i < nums.size() && nums[i] <= 0; ++i)
+        {
+            if (i != 0 && nums[i - 1] == nums[i]) 
+            {
+                continue;
+            }
+
+            int l = i + 1;
+            int r = nums.size() - 1;
+            while (l < r) 
+            {
+                int sum = nums[i] + nums[l] + nums[r];
+                if (sum < 0) 
+                {
+                    ++l;
+                }
+                else if (sum > 0) 
+                {
+                    --r;
+                }
+                else 
+                {
+                    res.push_back({nums[i], nums[l++], nums[r--]});
+                    while (l < r && nums[l] == nums[l - 1])
+                    {
+                        ++l;
+                    }
+                }
+            }
+        }
+
+        return res;
+    }
+};

3sum/hyeri0903.py

@@ -0,0 +1,39 @@
+from itertools import combinations
+
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        """
+        time complexity : O(n^2)
+        space complexity : O(1)
+        """
+        answer = []
+        nums.sort()
+        n = len(nums)
+
+        for i in range(n):
+            #skipped if nums[i] == nums[i-1] to avoid duplicate triplets
+            if i > 0 and nums[i] == nums[i-1]:
+                continue
+
+            #search with two pointer
+            left, right = i+1, n-1
+
+            while left < right:
+                total = nums[left] + nums[i] + nums[right]
+                if total == 0:
+                    answer.append([nums[left], nums[i], nums[right]])
+                    
+                    #move the pointers past duplicates
+                    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/junzero741.ts

@@ -0,0 +1,45 @@
+// TC: O(n^2)
+// SC: O(logn)
+function threeSum(nums: number[]): number[][] {
+    
+    nums.sort((a,b) => a-b);
+    const result: number[][] = []
+
+    for(let i = 0 ; i < nums.length; i++) {
+        let left = i+1;
+        let right = nums.length-1;
+
+        while(left < right) {
+           if(i > 0 && nums[i] === nums[i-1]) {
+                break;
+           }
+
+           const sum = nums[i] + nums[left] + nums[right];
+           if(sum > 0) {
+                right--;
+                continue;
+           }
+           if(sum < 0) {
+                left++;
+                continue;
+           }
+           if(sum === 0) {
+                const triplet: number[] = [nums[i], nums[left], nums[right]];
+                result.push(triplet);
+
+                while(left < right && nums[left] === nums[left+1]) {
+                    left++;
+                }
+                while(left < right && nums[right] === nums[right-1]) {
+                    right--;
+                }
+
+                left++;
+                right--;
+           }
+        }
+        
+    }
+
+    return result;
+};

3sum/mrlee7.py

@@ -0,0 +1,34 @@
+from typing import List
+
+
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        result: List[List[int]] = []
+        nums.sort()
+
+        for i in range(len(nums) - 2):
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+
+            left = i + 1
+            right = 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 += 1
+                    right -= 1
+
+                    while left < right and nums[left] == nums[left - 1]:
+                        left += 1
+                    while left < right and nums[right] == nums[right + 1]:
+                        right -= 1
+
+                elif total < 0:
+                    left += 1
+                else:
+                    right -= 1
+
+        return result

climbing-stairs/DaleSeo.rs

@@ -0,0 +1,16 @@
+// TC: O(n)
+// SC: O(1)
+impl Solution {
+    pub fn climb_stairs(n: i32) -> i32 {
+        if n < 3 {
+            return n;
+        }
+        let (mut pre, mut cur) = (1, 2);
+        for _ in 3..=n {
+            let next = pre + cur;
+            pre = cur;
+            cur = next;
+        }
+        cur
+    }
+}

climbing-stairs/Hyeri1ee.java

@@ -0,0 +1,28 @@
+import java.util.*;
+
+class Solution {
+    public int climbStairs(int n) {
+        int[] steps = new int[n+1];
+        if (n == 1) return 1;
+        if (n == 2) return 2;
+        if (n == 3) return 3;
+        steps[1] = 1; steps[2] = 2;//2, 1+1
+        steps[3] = 3;
+        for(int i = 4;i < n+1; i++){
+            steps[i] = steps[i-1] + steps[i-2];
+        }
+        /*
+        steps[4] = 
+        1+1+1+1
+        1+2+1
+        2+2
+        2+1+1
+        1+1+2
+        */
+
+        return steps[n];
+        
+
+    }
+}
+

climbing-stairs/OstenHun.cpp

@@ -0,0 +1,70 @@
+/*
+    You are climbing a staircase. It takes n steps to reach the top.
+
+    Each time you can either climb 1 or 2 steps. 
+    In how many distinct ways can you climb to the top?
+
+    Example 1:
+
+    Input: n = 2
+    Output: 2
+    Explanation: There are two ways to climb to the top.
+    1. 1 step + 1 step
+    2. 2 steps
+
+    Constraints:
+    1 <= n <= 45
+*/
+
+// TimeComplexity : O(n)
+// SpaceComplexity : O(n)
+#include <iostream>
+using namespace std;
+
+#pragma region DpArrayIdea
+namespace dp_array_idea {
+
+class Solution {
+public:
+    int climbStairs(int n) {
+        int dp[45];
+
+        // dp[i]는 i-1번째 칸을 오르는 경우의 수를 말한다.
+        dp[0] = 1;
+        dp[1] = 2;
+
+        for (int i = 2; i < n; i++) {
+            dp[i] = dp[i-1] + dp[i-2];
+        }
+
+        return dp[n-1];
+    }
+};
+
+}  // namespace dp_array_idea
+#pragma endregion
+
+// 배열을 사용하지 않는 풀이
+// Time : O(n)
+// Space : O(1)
+#pragma region FinalSolution
+class Solution {
+public:
+    int climbStairs(int n) {
+        if (n <= 2) {
+            return n;
+        }
+
+        int one_back = 1;
+        int two_back = 2;
+
+        for (int i = 3; i <= n; i++) {
+            int current = one_back + two_back;
+            two_back = one_back;
+            one_back = current;
+        }
+
+        return one_back;
+    }
+};
+#pragma endregion

climbing-stairs/Yu-Won.js

@@ -0,0 +1,22 @@
+/**
+ * 문제: https://leetcode.com/problems/climbing-stairs/description/
+ *
+ * 요구사항:
+ * n개의 계단이 있을 때
+ * 계단은 1, 2 칸씩 오를 수 있다.
+ * 이 계단을 오르는 방법은 총 몇가지 인가?
+ *
+ * * */
+
+const climbingStairs = (n) => {
+    if(n <= 1) return 1;
+    let prev1 = 1;
+    let prev2 = 1;
+    for(let i = 1; i < n; i++) {
+        let current = prev1 + prev2;
+        prev2 = prev1;
+        prev1 = current;
+    }
+
+    return prev1;
+}