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;
+    }
+}