Merge branch 'DaleStudy:main' into main

Author: Lustellz

3sum/hu6r1s.py

@@ -0,0 +1,28 @@
+class Solution:
+    """
+        1. 3 way for문으로 돌아가면서 0인 합을 찾는 방법
+            - O(n^3)으로 시간초과
+        2. 투포인터
+            - 정렬 후 투포인터를 이용하여 중복 제거와 최적화를 동시에 수행
+            - O(n^2)
+        공간 복잡도는 둘다 O(1)
+    """
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        result = set()
+        nums.sort()
+
+        for i in range(len(nums)):            
+            left, right = i + 1, len(nums) - 1
+            while left < right:
+                total = nums[i] + nums[left] + nums[right]
+
+                if total == 0:
+                    result.add((nums[i], nums[left], nums[right]))
+                    left += 1
+                    right -= 1
+                elif total < 0:
+                    left += 1
+                else:
+                    right -= 1
+
+        return list(result)

3sum/hyunjung-choi.kt

@@ -0,0 +1,35 @@
+class Solution {
+    fun threeSum(nums: IntArray): List<List<Int>> {
+        if (nums.size < 3) return emptyList()
+
+        val result = mutableSetOf<List<Int>>()
+
+        nums.sort()
+
+        for (i in 0 until nums.size - 2) {
+
+            if (i > 0 && nums[i] == nums[i - 1]) continue
+
+            var left = i + 1
+            var right = nums.size - 1
+
+            while (left < right) {
+                val sum = nums[i] + nums[left] + nums[right]
+
+                when {
+                    sum == 0 -> {
+                        result.add(listOf(nums[i], nums[left], nums[right]))
+
+                        left++
+                        right--
+                    }
+
+                    sum < 0 -> left++
+                    else -> right--
+                }
+            }
+        }
+
+        return result.toList()
+    }
+}

3sum/jongwanra.py

@@ -0,0 +1,106 @@
+"""
+[Problem]
+https://leetcode.com/problems/3sum/description/
+
+[Brainstorm]
+3 <= nums.length <= 3,000
+Brute Force: O(N^3) => 27,000,000,000 => time limited
+O(N^2)의 풀이는 시간 제한에 걸리지 않을 것으로 보인다. 3,000 * 3,000 => 9,000,000
+
+[Plan]
+1. map을 설정한다. key = elements value: index list
+2. nested-loop을 순회한다.
+    2-1. i == j인 경우 제외
+    2-2. map에서 동일한 인덱스인 경우 제외하고 구한다.
+
+"""
+
+from typing import List
+
+
+class Solution:
+    """
+    Attempt-1 My solution (incorrect)
+    time limited
+    """
+
+    def threeSum1(self, nums: List[int]) -> List[List[int]]:
+        map = {}
+        for index in range(len(nums)):
+            values = map.get(nums[index], [])
+            values.append(index)
+            map[nums[index]] = values
+
+        triplets = set()
+        for i in range(len(nums)):
+            for j in range(len(nums)):
+                if i == j:
+                    continue
+                complement = -(nums[i] + nums[j])
+                # print(f"nums[{i}]={nums[i]}, nums[{j}]={nums[j]} , complement={complement}")
+                if complement in map:
+                    values = map[complement]
+                    for k in values:
+                        if k == i or k == j:
+                            continue
+                        triplets.add(tuple(sorted([nums[i], nums[j], nums[k]])))
+        return list(triplets)
+
+    """
+    Attempt-2 Another solution
+    ref: https://www.algodale.com/problems/3sum/
+
+    """
+
+    def threeSum2(self, nums: List[int]) -> List[List[int]]:
+        triplets = set()
+
+        for index in range(len(nums) - 2):
+            seen = set()
+            for j in range(index + 1, len(nums)):
+                complement = -(nums[index] + nums[j])
+                if complement in seen:
+                    triplet = [nums[index], nums[j], complement]
+                    triplets.add(tuple(sorted(triplet)))
+                seen.add(nums[j])
+
+        return list(triplets)
+
+    """
+    Attempt-3 Another solution
+    ref: https://www.algodale.com/problems/3sum/
+
+    [Plan]
+    two-pointer로 접근한다.
+
+    [Complexity]
+    N: nums.length
+    Time: O(N^2)
+    Space: O(1)
+    """
+
+    def threeSum3(self, nums: List[int]) -> List[List[int]]:
+        triplets = set()
+        nums.sort()
+
+        for index in range(len(nums) - 2):
+            left = index + 1
+            right = len(nums) - 1
+
+            while left < right:
+                three_sum = nums[index] + nums[left] + nums[right]
+                if three_sum < 0:
+                    left += 1
+                    continue
+                if three_sum > 0:
+                    right -= 1
+                    continue
+                triplets.add((nums[index], nums[left], nums[right]))
+                left += 1
+                right -= 1
+        return list(triplets)
+
+
+sol = Solution()
+print(sol.threeSum3([-1, 0, 1, 2, -1, 4]))
+

3sum/mkwkw.cpp

@@ -0,0 +1 @@
+//set-up

climbing-stairs/hu6r1s.py

@@ -0,0 +1,25 @@
+class Solution:
+    """
+        1일 때, 1 step -> 1개
+        2일 때, 1 + 1, 2 -> 2개
+        3일 때, 1 + 1 + 1, 1 + 2, 2 + 1 -> 3개
+        4일 때, 1 + 1 + 1 + 1, 1 + 1 + 2, 1 + 2 + 1, 2 + 1 + 1, 2 + 2 -> 5개
+        5일 때, 1 + 1 + 1 + 1 + 1, 1 + 1 + 1 + 2, 1 + 1 + 2 + 1, 1 + 2 + 1 + 1, 2 + 1 + 1 + 1, 1 + 2 + 2, 2 + 1 + 2, 2 + 2 + 1 -> 8개
+        순서대로 봤을 때, 이전 값과 그 이전 값의 합이 현재 개수이다.
+        이를 점화식으로 봤을 때, dp[i] = d[i - 1] + dp[i - 2]가 된다.
+
+        - Time Complexity: O(n)
+            - 1부터 n까지 한 번씩 반복하므로 선형 시간
+        - Space Complexity: O(n)
+            - dp 배열에 n개의 값을 저장하므로 선형 공간 사용
+    """
+    def climbStairs(self, n: int) -> int:
+        if n == 1:
+            return n
+
+        dp = [0] * n
+        dp[0] = 1
+        dp[1] = 2
+        for i in range(2, n):
+            dp[i] = dp[i - 1] + dp[i - 2]
+        return dp[-1]

climbing-stairs/hyunjung-choi.kt

@@ -0,0 +1,16 @@
+class Solution {
+    fun climbStairs(n: Int): Int {
+        if (n <= 2) return n
+
+        var prev2 = 1
+        var prev1 = 2
+
+        for (i in 3..n) {
+            val current = prev1 + prev2
+            prev2 = prev1
+            prev1 = current
+        }
+
+        return prev1
+    }
+}

climbing-stairs/jongwanra.py

@@ -0,0 +1,98 @@
+"""
+[Problem]
+https://leetcode.com/problems/climbing-stairs/
+
+[Brainstorming]
+한 번에 갈 수 있는 계단: 1 or 2
+갈 수 있는 경우의 수를 구해야 하는 문제
+constraints: 1 <= n <= 45
+
+n = 1, 1
+n = 2, 2
+n = 3, 3
+n = 4, 5
+...
+f(n) = f(n - 1) + f(n - 2)
+
+[Plan]
+1. n + 1 크기의 list를 만든다.
+2. list[1] = 1, list[2] = 2를 대입한다.
+3. for-loop를 3부터 n까지 순회한다.
+    3-1. Bottom-Top 방식으로 n까지 값을 채워간다.
+4. n값을 반환한다.
+
+[Complexity]
+Time: O(n)
+Space: O(n)
+"""
+
+
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        answer = [0, 1, 2]
+        for index in range(3, n + 1):
+            answer.append(answer[index - 1] + answer[index - 2])
+
+        return answer[n]
+
+    """
+    another solution
+    ref: https://www.algodale.com/problems/climbing-stairs/
+    [Summary]
+    Bottom Top 방식인데 공간을 최적화하여 접근
+    [Complexity]
+    Time: O(n)
+    Space: O(1) - Space Optimization
+
+    [Plan]
+    1. prev = 1, cur = 2를 저장한다.
+    2. for-loop를 순회한다. 3 to n + 1
+
+    """
+
+    def climbStairs2(self, n: int) -> int:
+        if n <= 3:
+            return n
+
+        prev, cur = [2, 3]
+        for index in range(4, n + 1):
+            tmp = cur
+            cur = cur + prev
+            prev = tmp
+        return cur
+
+    """
+    another solution
+    ref: https://www.algodale.com/problems/climbing-stairs/
+    [Summary]
+    Top-Bottom으로 재귀적으로 접근
+    [Complexity]
+    Time: O(n)
+    Space: O(n)
+    """
+
+    def climbStairs3(self, n: int) -> int:
+        cache = {}
+
+        def dfs(num: int) -> int:
+            nonlocal cache
+            if num <= 3:
+                return num
+            if num in cache:
+                return cache[num]
+            cache[num] = dfs(num - 1) + dfs(num - 2)
+            return cache[num]
+
+        return dfs(n)
+
+
+sol = Solution()
+
+# Normal Case
+print(sol.climbStairs3(2) == 2)
+print(sol.climbStairs3(3) == 3)
+print(sol.climbStairs3(4) == 5)
+print(sol.climbStairs3(5) == 8)
+print(sol.climbStairs3(38))
+# Edge Case
+print(sol.climbStairs3(1) == 1)

climbing-stairs/mkwkw.cpp

@@ -0,0 +1,20 @@
+//Dynamic Programming
+//dp[n] = dp[n-1]+dp[n-2]
+class Solution {
+public:
+    int climbStairs(int n) {
+        int dp[46];
+        
+        dp[0] = 0;
+        dp[1] = 1;
+        dp[2] = 2;
+
+        for(int i=3; i<=n; i++)
+        {
+            dp[i] = dp[i-1]+dp[i-2];
+        }
+
+        return dp[n];
+
+    }
+};

contains-duplicate/yhkee0404.kt

@@ -0,0 +1,6 @@
+class Solution {
+    fun containsDuplicate(nums: IntArray): Boolean {
+        return nums.toSet()
+                .size != nums.size
+    }
+}

house-robber/yhkee0404.rs

@@ -0,0 +1,11 @@
+impl Solution {
+    pub fn rob(nums: Vec<i32>) -> i32 {
+        let mut dp = vec![0; nums.len() + 1];
+        dp[1] = nums[0];
+        for i in 2..dp.len() {
+            dp[i] = dp[i - 1].max(dp[i - 2] + nums[i - 1]);
+        }
+        return *dp.last()
+                .unwrap_or(&0)
+    }
+}