Merge branch 'DaleStudy:main' into main

Author: jdy8739

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: DaleStudy

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 DaleStudy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

find-median-from-data-stream/forest000014.java

@@ -0,0 +1,49 @@
+/*
+# Time Complexity: O(nlogn)
+# Space Complexity: O(nlogn)
+
+*/
+class MedianFinder {
+
+    private PriorityQueue<Integer> pq1; // 1번째 ~ 가운데 원소 (max heap)
+    private PriorityQueue<Integer> pq2; // 가운데+1번째 ~ 마지막 원소 (min heap)
+
+    public MedianFinder() {
+        pq1 = new PriorityQueue<>(Collections.reverseOrder());
+        pq2 = new PriorityQueue<>();
+    }
+
+    public void addNum(int num) {
+
+        if (pq1.size() == pq2.size()) {
+            if (pq1.peek() == null || pq1.peek() >= num) {
+                pq1.add(num);
+            } else {
+                pq2.add(num);
+                pq1.add(pq2.poll());
+            }
+        } else {
+            if (pq1.peek() == null || pq1.peek() >= num) {
+                pq1.add(num);
+                pq2.add(pq1.poll());
+            } else {
+                pq2.add(num);
+            }
+        }
+    }
+
+    public double findMedian() {
+        if (pq1.size() == pq2.size()) {
+            return (pq1.peek() + pq2.peek()) / 2.0;
+        } else {
+            return pq1.peek();
+        }
+    }
+}
+
+/**
+ * Your MedianFinder object will be instantiated and called as such:
+ * MedianFinder obj = new MedianFinder();
+ * obj.addNum(num);
+ * double param_2 = obj.findMedian();
+ */

find-median-from-data-stream/gwbaik9717.js

@@ -0,0 +1,131 @@
+// last test case failed
+// Time complexity: O(logn)
+// Space complexity: O(n)
+
+class MinHeap {
+  constructor() {
+    this.heap = [null];
+  }
+
+  get root() {
+    if (this.length === 1) {
+      return null;
+    }
+
+    return this.heap[1];
+  }
+
+  get length() {
+    return this.heap.length;
+  }
+
+  push(value) {
+    this.heap.push(value);
+
+    let current = this.heap.length - 1;
+    let parent = Math.floor(current / 2);
+
+    while (parent && this.heap[current] < this.heap[parent]) {
+      [this.heap[current], this.heap[parent]] = [
+        this.heap[parent],
+        this.heap[current],
+      ];
+      current = parent;
+      parent = Math.floor(current / 2);
+    }
+  }
+
+  pop() {
+    if (this.heap.length === 1) {
+      return null;
+    }
+
+    if (this.heap.length === 2) {
+      return this.heap.pop();
+    }
+
+    const rv = this.heap[1];
+    this.heap[1] = this.heap.pop();
+
+    let current = 1;
+    let left = current * 2;
+    let right = left + 1;
+
+    while (
+      (this.heap[left] && this.heap[current] > this.heap[left]) ||
+      (this.heap[right] && this.heap[current] > this.heap[right])
+    ) {
+      if (this.heap[right] && this.heap[right] < this.heap[left]) {
+        [this.heap[right], this.heap[current]] = [
+          this.heap[current],
+          this.heap[right],
+        ];
+        current = right;
+      } else {
+        [this.heap[left], this.heap[current]] = [
+          this.heap[current],
+          this.heap[left],
+        ];
+        current = left;
+      }
+
+      left = current * 2;
+      right = left + 1;
+    }
+
+    return rv;
+  }
+}
+
+var MedianFinder = function () {
+  this.leftMinHeap = new MinHeap();
+  this.rightMinHeap = new MinHeap();
+};
+
+/**
+ * @param {number} num
+ * @return {void}
+ */
+MedianFinder.prototype.addNum = function (num) {
+  const rightMinValue = this.rightMinHeap.root;
+
+  if (num >= rightMinValue) {
+    this.rightMinHeap.push(num);
+  } else {
+    this.leftMinHeap.push(num * -1);
+  }
+
+  if (this.rightMinHeap.length - this.leftMinHeap.length > 1) {
+    const popped = this.rightMinHeap.pop();
+    this.leftMinHeap.push(popped * -1);
+  }
+
+  if (this.leftMinHeap.length - this.rightMinHeap.length > 1) {
+    const popped = this.leftMinHeap.pop();
+    this.rightMinHeap.push(popped * -1);
+  }
+};
+
+/**
+ * @return {number}
+ */
+MedianFinder.prototype.findMedian = function () {
+  const len = this.leftMinHeap.length + this.rightMinHeap.length;
+
+  if (len % 2 === 0) {
+    return (this.leftMinHeap.root * -1 + this.rightMinHeap.root) / 2;
+  }
+
+  if (this.leftMinHeap.length > this.rightMinHeap.length) {
+    return this.leftMinHeap.root * -1;
+  }
+
+  return this.rightMinHeap.root;
+};
+
+/**
+ * Your MedianFinder object will be instantiated and called as such:
+ * var obj = new MedianFinder()
+ * obj.addNum(num)
+ * var param_2 = obj.findMedian()
+ */

find-median-from-data-stream/imsosleepy.java

@@ -0,0 +1,60 @@
+// 메모리초과로 알 수 있었던 것은 저장 공간이 여러개 필요하다는 거 였다.
+// 그리고 주어진 데이터가 정렬되지 않아서 무조건 nlog(n) 이상의 시간복잡도가 나오기 때문에
+// 자동 정렬할 수 있는 우선순위 큐를 사용하면 좋겠따고 생각
+// 그러나 데이터를 나누는 알고리즘이 필요한지 모르고 헤메다가 GPT 답을 보게됨
+// 시간복잡도 우선순위 큐 : O(logN)
+class MedianFinder {
+    private PriorityQueue<Integer> maxHeap;
+    private PriorityQueue<Integer> minHeap;
+
+    public MedianFinder() {
+        maxHeap = new PriorityQueue<>(Collections.reverseOrder());
+        minHeap = new PriorityQueue<>();
+    }
+
+    public void addNum(int num) {
+        maxHeap.offer(num);
+
+        if (!minHeap.isEmpty() && maxHeap.peek() > minHeap.peek()) {
+            minHeap.offer(maxHeap.poll());
+        }
+
+        if (maxHeap.size() > minHeap.size() + 1) {
+            minHeap.offer(maxHeap.poll());
+        } else if (minHeap.size() > maxHeap.size()) {
+            maxHeap.offer(minHeap.poll());
+        }
+    }
+
+    public double findMedian() {
+        if (maxHeap.size() > minHeap.size()) {
+            return maxHeap.peek();
+        } else {
+            return (maxHeap.peek() + minHeap.peek()) / 2.0;
+        }
+    }
+}
+
+// 메모리초과
+class MedianFinder {
+    private List<Integer> arr;
+
+    public MedianFinder() {
+        arr = new ArrayList<>();
+    }
+
+    public void addNum(int num) {
+        arr.add(num);
+    }
+
+    public double findMedian() {
+        Collections.sort(arr);
+
+        int size = arr.size();
+        if (size % 2 == 1) {
+            return arr.get(size / 2);
+        } else {
+            return (arr.get(size / 2 - 1) + arr.get(size / 2)) / 2.0;
+        }
+    }
+}

find-median-from-data-stream/yolophg.py

@@ -0,0 +1,31 @@
+# Time Complexity:
+#   - addNum(): O(log N) - use a heap operation (push/pop) which takes log N time.
+#   - findMedian(): O(1) - just accessing the top elements of heaps.
+# Space Complexity: O(N) - store all elements in two heaps.
+
+
+class MedianFinder:
+    def __init__(self):
+        # max heap (stores the smaller half of numbers, negated values for max heap behavior)
+        self.maxHeap = []
+        # min heap (stores the larger half of numbers)
+        self.minHeap = []
+
+    def addNum(self, num: int) -> None:
+        if not self.maxHeap or num <= -self.maxHeap[0]:
+            # store as negative to simulate max heap
+            heapq.heappush(self.maxHeap, -num)  
+        else:
+            heapq.heappush(self.minHeap, num)
+
+        # balance the heaps: maxHeap can have at most 1 more element than minHeap
+        if len(self.maxHeap) > len(self.minHeap) + 1:
+            heapq.heappush(self.minHeap, -heapq.heappop(self.maxHeap))
+        elif len(self.minHeap) > len(self.maxHeap):
+            heapq.heappush(self.maxHeap, -heapq.heappop(self.minHeap))
+
+    def findMedian(self) -> float:
+        if len(self.maxHeap) > len(self.minHeap):
+            return -self.maxHeap[0]  # odd number of elements, maxHeap has the median
+        else:
+            return (-self.maxHeap[0] + self.minHeap[0]) / 2.0  # even case, average of two middle numbers

insert-interval/KwonNayeon.py

@@ -0,0 +1,50 @@
+"""
+Constraints:
+- 0 <= intervals.length <= 10^4
+- intervals[i].length == 2
+- 0 <= starti <= endi <= 10^5
+- intervals is sorted by starti in ascending order.
+- newInterval.length == 2
+- 0 <= start <= end <= 10^5
+
+Time Complexity: O(n)
+- 모든 interval을 한 번씩만 처리함
+
+Space Complexity: O(n)
+- 최악의 경우 모든 interval을 결과 리스트에 저장
+
+풀이방법:
+1. 세 단계로 구분하여 처리:
+  - Step 1: newInterval보다 앞에 있는 intervals → 결과에 바로 추가
+  - Step 2: newInterval과 겹치는 intervals → 병합하여 하나의 interval로 만듦
+  - Step 3: newInterval보다 뒤에 있는 intervals → 결과에 바로 추가
+2. 병합 조건:
+  - 두 interval이 겹치는 조건: intervals[i][0] <= mergedInterval[1]
+  - 병합 시 시작점: min(mergedInterval[0], intervals[i][0])
+  - 병합 시 끝점: max(mergedInterval[1], intervals[i][1])
+
+노트: 
+- 세 단계로 구분하여 처리하는 게 쉽지 않았다. 다음에 풀 땐 스스로 해결해볼 것
+"""
+class Solution:
+    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
+        result = []
+        i = 0
+        n = len(intervals)
+
+        while i < n and intervals[i][1] < newInterval[0]:
+            result.append(intervals[i])
+            i += 1
+
+        merged_interval = newInterval
+        while i < n and intervals[i][0] <= merged_interval[1]:
+            merged_interval[0] = min(merged_interval[0], intervals[i][0])
+            merged_interval[1] = max(merged_interval[1], intervals[i][1])
+            i += 1
+        result.append(merged_interval)
+
+        while i < n:
+            result.append(intervals[i])
+            i += 1
+
+        return result

insert-interval/YeomChaeeun.ts

@@ -0,0 +1,38 @@
+/**
+ * 중간에 새로운 구간 추가하기
+ * 알고리즘 복잡도
+ * - 시간 복잡도: O(n)
+ * - 공간 복잡도: O(n)
+ * @param intervals
+ * @param newInterval
+ */
+function insert(intervals: number[][], newInterval: number[]): number[][] {
+    if(intervals.length === 0) return [newInterval]
+    let result: number[][] = []
+
+    let i = 0;
+
+    // 1. newIntervals 이전 구간 추가
+    while(i < intervals.length && intervals[i][1] < newInterval[0]) {
+        result.push(intervals[i])
+        i++
+    }
+
+    // 2. 겹치는 부분 추가
+    const merged = [...newInterval]
+    while(i < intervals.length && intervals[i][0] <= newInterval[1]) {
+        merged[0] = Math.min(merged[0], intervals[i][0])
+        merged[1] = Math.max(merged[1], intervals[i][1])
+        i++
+    }
+    result.push(merged)
+
+    // 3. 이후의 구간 추가
+    while(i < intervals.length) {
+        result.push(intervals[i])
+        i++
+    }
+
+    return result
+}
+