Merge branch 'DaleStudy:main' into main

Author: dev-jonghoonpark

insert-interval/Leo.py

@@ -0,0 +1,17 @@
+class Solution:
+    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
+        left = []
+        right = []
+
+        for interval in intervals:
+            if interval[1] < newInterval[0]:
+                left.append(interval)
+            elif interval[0] > newInterval[1]:
+                right.append(interval)
+            else:
+                newInterval[0] = min(newInterval[0], interval[0])
+                newInterval[1] = max(newInterval[1], interval[1])
+
+        return left + [newInterval] + right
+
+        ## TC: O(n), SC: O(n)

insert-interval/nhistory.js

@@ -0,0 +1,29 @@
+var insert = function (intervals, newInterval) {
+  let result = [];
+  let i = 0;
+
+  // 1. Add all intervals before the new interval
+  while (i < intervals.length && intervals[i][1] < newInterval[0]) {
+    result.push(intervals[i]);
+    i++;
+  }
+
+  // 2. Merge all overlapping intervals with new interval
+  while (i < intervals.length && intervals[i][0] <= newInterval[1]) {
+    newInterval[0] = Math.min(newInterval[0], intervals[i][0]);
+    newInterval[1] = Math.max(newInterval[1], intervals[i][1]);
+    i++;
+  }
+  result.push(newInterval);
+
+  // 3. Add all intervals after the new interval
+  while (i < intervals.length && intervals[i][1] >= newInterval[0]) {
+    result.push(intervals[i]);
+    i++;
+  }
+
+  return result;
+};
+
+// TC = O(n)
+// SC = O(n)

insert-interval/yolophg.js

@@ -0,0 +1,30 @@
+// Time Complexity: O(n log n)
+// Space Complexity: O(n)
+
+var insert = function (intervals, newInterval) {
+  // append the newInterval to the intervals array
+  intervals.push(newInterval);
+
+  // sort the intervals array by start time
+  intervals.sort((a, b) => a[0] - b[0]);
+
+  // to store merged intervals
+  let result = [];
+
+  // iterate through the sorted intervals array
+  for (let i = 0; i < intervals.length; i++) {
+    // if the result array is empty or the current interval does not overlap with the last interval
+    if (result.length === 0 || result[result.length - 1][1] < intervals[i][0]) {
+      result.push(intervals[i]); // Add the current interval to the result array
+    } else {
+      // if there is an overlap, merge the current interval with the last interval
+      result[result.length - 1][1] = Math.max(
+        result[result.length - 1][1],
+        intervals[i][1]
+      );
+    }
+  }
+
+  // return the final merged intervals
+  return result;
+};

jump-game/bky373.java

@@ -0,0 +1,15 @@
+// time: O(N)
+// space: O(1)
+class Solution {
+
+    public boolean canJump(int[] nums) {
+        int lastPosition = nums.length - 1;
+
+        for (int i = nums.length - 1; i >= 0; i--) {
+            if (i + nums[i] >= lastPosition) {
+                lastPosition = i;
+            }
+        }
+        return lastPosition == 0;
+    }
+}

jump-game/evan.py

@@ -0,0 +1,13 @@
+def canJump(nums):
+    n = len(nums)
+    dp = [False] * n
+    dp[0] = True
+
+    for i in range(n):
+        if dp[i]:
+            maxJump = min(i + nums[i], n - 1)
+            
+            for j in range(i + 1, maxJump + 1):
+                dp[j] = True
+
+    return dp[n - 1]

jump-game/samthekorean.py

@@ -0,0 +1,10 @@
+# TC : O(n)
+# SC : O(1)
+class Solution:
+    def canJump(self, nums):
+        reachable = 0
+        for i in range(len(nums)):
+            if i > reachable:
+                return False
+            reachable = max(reachable, i + nums[i])
+        return True

longest-common-subsequence/bky373.java

@@ -0,0 +1,20 @@
+// time: O(m*n)
+// space: O(m*n)
+class Solution {
+
+    public int longestCommonSubsequence(String text1, String text2) {
+        int[][] dp = new int[text1.length() + 1][text2.length() + 1];
+
+        for (int col = text2.length() - 1; col >= 0; col--) {
+            for (int row = text1.length() - 1; row >= 0; row--) {
+                if (text1.charAt(row) == text2.charAt(col)) {
+                    dp[row][col] = 1 + dp[row + 1][col + 1];
+                } else {
+                    dp[row][col] = Math.max(dp[row + 1][col], dp[row][col + 1]);
+                }
+            }
+        }
+
+        return dp[0][0];
+    }
+}

longest-common-subsequence/evan.py

@@ -0,0 +1,18 @@
+class Solution:
+    def longestCommonSubsequence(self, text1, text2):
+        text1_length, text2_length = len(text1), len(text2)
+        # dp[i][j]는 text1의 처음 i 글자와 text2의 처음 j 글자의 LCS 길이를 의미합니다.
+        dp = [[0] * (text2_length + 1) for _ in range(text1_length + 1)]
+
+        for text1_char in range(1, text1_length + 1):
+            for text2_char in range(1, text2_length + 1):
+                if text1[text1_char - 1] == text2[text2_char - 1]:
+                    # 두 문자가 같으면 그 이전까지의 LCS 길이에 1을 더한 값으로 현재 위치를 갱신합니다.
+                    dp[text1_char][text2_char] = dp[text1_char - 1][text2_char - 1] + 1
+                else:
+                    # 두 문자가 다르면 이전까지의 최대 LCS 길이 중 더 큰 값을 현재 위치에 저장합니다.
+                    dp[text1_char][text2_char] = max(
+                        dp[text1_char - 1][text2_char], dp[text1_char][text2_char - 1]
+                    )
+
+        return dp[text1_length][text2_length]

longest-common-subsequence/samthekorean.py

@@ -0,0 +1,13 @@
+# m is the length of text1 and n is the length of text2
+# TC : O(m * n)
+# SC : O(m * n)
+class Solution:
+    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
+        dp = [[0] * (len(text2) + 1) for _ in range(len(text1) + 1)]
+        for r in range(1, len(text1) + 1):
+            for c in range(1, len(text2) + 1):
+                if text1[r - 1] == text2[c - 1]:
+                    dp[r][c] = 1 + dp[r - 1][c - 1]
+                else:
+                    dp[r][c] = max(dp[r - 1][c], dp[r][c - 1])
+        return dp[-1][-1]

longest-increasing-subsequence/bky373.java

@@ -0,0 +1,24 @@
+// time: O(N^2)
+// space: O(N)
+class Solution {
+
+    public int lengthOfLIS(int[] nums) {
+        int[] dp = new int[nums.length];
+        Arrays.fill(dp, 1);
+
+        for (int i = 1; i < nums.length; i++) {
+            for (int j = 0; j < i; j++) {
+                if (nums[i] > nums[j]) {
+                    dp[i] = Math.max(dp[i], dp[j] + 1);
+                }
+            }
+        }
+
+        int longest = 0;
+        for (int count : dp) {
+            longest = Math.max(longest, count);
+        }
+
+        return longest;
+    }
+}

longest-increasing-subsequence/evan.py

@@ -0,0 +1,19 @@
+import bisect
+from typing import List
+
+
+class Solution:
+    def lengthOfLIS(self, nums: List[int]) -> int:
+        lis = []
+
+        for num in nums:
+            # num이 왼쪽에 삽입될 수 있는 위치
+            position = bisect.bisect_left(lis, num)
+
+            # num이 lis에 있는 모든 요소 보다 크다
+            if position == len(lis):
+                lis.append(num)
+            else:
+                lis[position] = num
+
+        return len(lis)

longest-increasing-subsequence/samthekorean.py

@@ -0,0 +1,10 @@
+# TC : O(n^2)
+# SC : O(n)
+class Solution:
+    def lengthOfLIS(self, nums: List[int]) -> int:
+        dp = [1] * len(nums)
+        for cur in range(1, len(nums)):
+            for pre in range(cur):
+                if nums[pre] < nums[cur]:
+                    dp[cur] = max(1 + dp[pre], dp[cur])
+        return max(dp)

maximum-subarray/bky373.java

@@ -0,0 +1,17 @@
+// time: O(N)
+// space: O(1)
+class Solution {
+
+    public int maxSubArray(int[] nums) {
+        int currentSum = nums[0];
+        int maxSum = nums[0];
+
+        for (int i = 1; i < nums.length; i++) {
+            int k = nums[i];
+            currentSum = Math.max(k, currentSum + k);
+            maxSum = Math.max(maxSum, currentSum);
+        }
+
+        return maxSum;
+    }
+}

maximum-subarray/evan.py

@@ -0,0 +1,13 @@
+from typing import List
+
+
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+        global_max_sum = nums[0]
+        local_max_sum = nums[0]
+        
+        for num in nums[1:]:
+            local_max_sum = max(num, local_max_sum + num)
+            global_max_sum = max(global_max_sum, local_max_sum)
+
+        return global_max_sum

maximum-subarray/samthekorean.py

@@ -0,0 +1,15 @@
+# TC : O(n)
+# SC : O(1)
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+        res = nums[0]
+        total = 0
+
+        for n in nums:
+            if total < 0:
+                total = 0
+
+            total += n
+            res = max(res, total)
+
+        return res

meeting-rooms-ii/Leo.py

@@ -0,0 +1,19 @@
+class Solution:
+    def minMeetingRooms(self, intervals: List[List[int]]) -> int:
+        if not intervals:
+            return 0
+
+        rooms_needed, end_pointer = 0, 0
+
+        start_times = sorted([interval[0] for interval in intervals])
+        end_times = sorted([interval[1] for interval in intervals])
+
+        for i in range(len(start_times)):
+            if start_times[i] >= end_times[end_pointer]:
+                end_pointer += 1
+            else:
+                rooms_needed += 1
+
+        return rooms_needed
+
+        ## TC: O(nlogn), SC: O(n)

meeting-rooms-ii/nhistory.js

@@ -0,0 +1,29 @@
+class Solution {
+  /**
+   * @param {Interval[]} intervals
+   * @returns {number}
+   */
+  minMeetingRooms(intervals) {
+    // Edge case
+    if (intervals.length === 0) return 0;
+
+    let startTimes = intervals.map((interval) => interval.start);
+    let endTimes = intervals.map((interval) => interval.end);
+
+    startTimes.sort((a, b) => a - b);
+    endTimes.sort((a, b) => a - b);
+
+    let roomNeeded = 0;
+    let endIndex = 0;
+
+    for (let i = 0; i < intervals.length; i++) {
+      if (startTimes[i] < endTimes[endIndex]) roomNeeded++;
+      else endIndex++;
+    }
+
+    return roomNeeded;
+  }
+}
+
+// TC: O(nlogn)
+// SC: O(n)

meeting-rooms-ii/yolophg.js

@@ -0,0 +1,38 @@
+// Time Complexity: O(n log n)
+// Space Complexity: O(n)
+
+export class Solution {
+  minMeetingRooms(intervals) {
+    // separate start and end times into different arrays
+    let startTimes = intervals.map((interval) => interval[0]);
+    let endTimes = intervals.map((interval) => interval[1]);
+
+    // sort the start and end times
+    startTimes.sort((a, b) => a - b);
+    endTimes.sort((a, b) => a - b);
+
+    let startPointer = 0;
+    let endPointer = 0;
+    let rooms = 0;
+    let maxRooms = 0;
+
+    // iterate over all the start times
+    while (startPointer < intervals.length) {
+      // if the start time is less than the end time, a new room is needed
+      if (startTimes[startPointer] < endTimes[endPointer]) {
+        rooms++;
+        startPointer++;
+      } else {
+        // if the start time is not less than the end time, free up a room
+        rooms--;
+        endPointer++;
+      }
+
+      // update the maximum number of rooms needed
+      maxRooms = Math.max(maxRooms, rooms);
+    }
+
+    // return the maximum number of rooms needed
+    return maxRooms;
+  }
+}

merge-intervals/Leo.py

@@ -0,0 +1,20 @@
+class Solution:
+    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
+        def sort_key(interval):
+            return interval[0]
+
+        intervals.sort(key=sort_key)
+
+        result = [intervals[0]]
+
+        for start, end in intervals[1:]:
+            lastEnd = result[-1][1]
+
+            if start <= lastEnd:
+                result[-1][1] = max(lastEnd, end)
+            else:
+                result.append([start, end])
+
+        return result
+
+        ## TC: O(nlogn), SC: O(n)