Merge branch 'DaleStudy:main' into main

Author: EcoFriendlyAppleSu

.github/workflows/integration.yaml

@@ -85,7 +85,7 @@ jobs:
       - name: Check filename rules
         if: ${{ steps.pr-labels.outputs.has_maintenance != 'true' }}
         run: |
-          files=$(git diff --name-only ${{ github.event.pull_request.base.sha }} ${{ github.sha }} | tr -d '"')
+          files=$(git diff --name-only ${{ github.event.pull_request.base.sha }} ${{ github.event.pull_request.head.sha }} | tr -d '"')
           pr_author="${{ github.event.pull_request.user.login }}"
           success=true
 

contains-duplicate/5YoonCheol.java

@@ -0,0 +1,16 @@
+class Solution {
+    /**
+     *   시간 복잡도: O(N)
+     *   공간 복잡도: O(N)
+     */
+    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;
+    }
+}

contains-duplicate/Gotprgmer.java

@@ -0,0 +1,30 @@
+import java.util.HashSet;
+import java.util.Set;
+
+class SolutionGotprgmer {
+    // 해당 문제는 어느 한 숫자가 2개이상 존재할 경우 true를 그렇지 않을 경우, false를 반환하는 문제이다.
+    // set을 사용해서 set에 이미 값이 존재한다면 개수가 2 이상이므로 true 그렇지 않으면 false를 출력한다.
+
+    // 각 숫자들을 저장해서 set으로 관리 -> distinctNums
+    // nums의 각 숫자인 checkNum을 distinctNums에 넣어준다.
+    // 만약 checkNum이 이미 distinctNums에 존재한다면 ans를 true로 만들어주고 답을 출력한다.
+
+
+    // 시간복잡도 -> O(n)
+    // 공간복잡도 -> O(n)
+    static Set<Integer> distinctNums;
+    public boolean containsDuplicate(int[] nums) {
+        distinctNums = new HashSet<>();
+        boolean ans = false;
+        for (int checkNum : nums) {
+            if (distinctNums.contains(checkNum)) {
+                ans = true;
+                break;
+            };
+            distinctNums.add(checkNum);
+        }
+        return ans;
+    }
+
+
+}

contains-duplicate/dusunax.py

@@ -0,0 +1,23 @@
+'''
+# Leetcode 217. Contains Duplicate
+
+use set to store distinct elements 🗂️
+
+## Time and Space Complexity
+
+```
+TC: O(n)
+SC: O(n)
+```
+
+### TC is O(n):
+- iterating through the list just once to convert it to a set.
+
+### SC is O(n):
+- creating a set to store the distinct elements of the list.
+'''
+
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        return len(nums) != len(set(nums))
+

contains-duplicate/thispath98.py

@@ -0,0 +1,15 @@
+"""
+# Time Complexity: O(N)
+- N번 순회
+# Space Compelexity: O(N)
+- 최악의 경우 (중복된 값이 없을 경우) N개 저장
+"""
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        num_dict = {}
+        for num in nums:
+            if num not in num_dict:
+                num_dict[num] = True
+            else:
+                return True
+        return False

house-robber/5YoonCheol.java

@@ -0,0 +1,19 @@
+class Solution {
+    public int rob(int[] nums) {
+        //배열 길이 0이면 털 수 있는 집이 없음.
+        if (nums.length == 0) return 0;
+        //배열 길이가 1이면 한 집만 털 수 있음.
+        if (nums.length == 1) return nums[0];
+
+        //동적 계획법으로 풀이
+        int[] dp = new int[nums.length];
+        dp[0] = nums[0];
+        dp[1] = Math.max(nums[0], nums[1]);
+
+        //배열 크기가 2이상일 경우 최대 금액의 범위 확장
+        for (int i = 2; i < nums.length; i++) {
+            dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 1]);
+        }
+        return dp[nums.length - 1];
+    }
+}

house-robber/dusunax.py

@@ -0,0 +1,44 @@
+'''
+# Leetcode 198. House Robber
+
+use **dynamic programming** to solve this problem. (bottom-up approach) 🧩
+
+choose bottom-up approach for less space complexity.
+
+## DP relation
+
+```
+dp[i] = max(dp[i - 1], dp[i - 2] + nums[i])
+```
+
+- **dp[i - 1]:** skip and take the value from the previous house
+- **dp[i - 2]:** rob the current house, add its value to the maximum money from two houses before
+
+## Time and Space Complexity
+
+```
+TC: O(n)
+SC: O(n)
+```
+
+### TC is O(n):
+- iterating through the list just once to calculate the maximum money. = O(n)
+
+### SC is O(n):
+- using a list to store the maximum money at each house. = O(n)
+
+'''
+
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        if len(nums) == 1:
+            return nums[0]
+
+        dp = [0] * len(nums)
+        dp[0] = nums[0]
+        dp[1] = max(nums[0], nums[1])
+
+        for i in range(2, len(nums)):
+            dp[i] = max(dp[i - 1], dp[i - 2] + nums[i])
+            
+        return dp[-1]

house-robber/thispath98.py

@@ -0,0 +1,19 @@
+"""
+# Time Complexity: O(N)
+- N개의 개수를 가지는 dp 리스트를 만들고, 이를 순회
+# Space Compelexity: O(N)
+- N개의 dp 리스트 저장
+"""
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        if len(nums) == 1:
+            return nums[0]
+
+        dp = [0 for _ in range(len(nums))]
+        dp[0] = nums[0]
+        dp[1] = max(nums[0], nums[1])
+
+        for i in range(len(nums) - 2):
+            dp[i + 2] = max(dp[i] + nums[i + 2], dp[i + 1])
+
+        return max(dp[-2], dp[-1])

longest-common-subsequence/thispath98.py

@@ -0,0 +1,37 @@
+"""
+# Time Complexity: O(N)
+- lce_dict 생성: N
+- N개의 key에 대하여 순회하면서 값 확인: N
+# Space Compelexity: O(k)
+- 중복되지 않은 key k개 저장
+"""
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        if not nums:
+            return 0
+
+        lce_dict = {}
+        for num in nums:
+            lce_dict[num] = True
+
+        answer = 0
+        for num in nums:
+            cur_lce = 1
+            if lce_dict.pop(num, None) is None:
+                continue
+
+            down_num = num - 1
+            while down_num in lce_dict:
+                cur_lce += 1
+                lce_dict.pop(down_num)
+                down_num -= 1
+                
+            up_num = num + 1
+            while up_num in lce_dict:
+                cur_lce += 1
+                lce_dict.pop(up_num)
+                up_num += 1
+
+            answer = answer if answer > cur_lce else cur_lce
+
+        return answer

longest-consecutive-sequence/5YoonCheol.java

@@ -0,0 +1,34 @@
+import java.util.*;
+
+class Solution {
+    public int longestConsecutive(int[] nums) {
+        if (nums == null || nums.length == 0) return 0;
+
+        //모든 요소 HashSet 삽입
+        HashSet<Integer> set = new HashSet<>();
+        for (int num : nums) {
+            set.add(num);
+        }
+
+        int longest = 0;
+
+        // 시작지점 체크
+        for (int num : nums) {
+            //배열 요소보다 1 작은 수 가 없는 경우 새로운 시작 지점이 됨
+            if (!set.contains(num - 1)) {
+                int start = num;
+                int currentLength = 1;
+
+                // 1씩 증가시키면서 연속된 수의 개수 탐색
+                while (set.contains(start + 1)) {
+                    start++;
+                    currentLength++;
+                }
+                // 기존 longest와 현재 연속된 수를 비교
+                longest = Math.max(longest, currentLength);
+            }
+        }
+
+        return longest;
+    }
+}