Merge branch 'DaleStudy:main' into main

Author: jylee2033

best-time-to-buy-and-sell-stock/hyejj19.ts

@@ -0,0 +1,26 @@
+function maxProfit(prices: number[]): number {
+  let minPrice = Number.MAX_SAFE_INTEGER;
+  let maxProfit = 0;
+
+  for (let p of prices) {
+    if (minPrice >= p) {
+      minPrice = p;
+      continue;
+    } else {
+      let profit = p - minPrice;
+      if (profit > maxProfit) maxProfit = profit;
+    }
+  }
+  return maxProfit;
+}
+
+function maxProfit(prices: number[]): number {
+  let minPrice = Infinity;
+  let maxProfit = 0;
+
+  for (let p of prices) {
+    minPrice = Math.min(minPrice, p);
+    maxProfit = Math.max(maxProfit, p - minPrice);
+  }
+  return maxProfit;
+}

container-with-most-water/Cyjin-jani.js

@@ -0,0 +1,22 @@
+// tc: O(n);
+// sc: O(1);
+const maxArea = function (height) {
+  let max = 0;
+  let leftIdx = 0;
+  let rightIdx = height.length - 1;
+
+  while (leftIdx < rightIdx) {
+    const width = rightIdx - leftIdx;
+    const minHeight = Math.min(height[leftIdx], height[rightIdx]);
+    const area = width * minHeight;
+    max = Math.max(max, area);
+
+    if (height[leftIdx] > height[rightIdx]) {
+      rightIdx -= 1;
+    } else {
+      leftIdx += 1;
+    }
+  }
+
+  return max;
+};

container-with-most-water/DaleSeo.rs

@@ -0,0 +1,20 @@
+// TC: O(n)
+// SC: O(1)
+impl Solution {
+    pub fn max_area(height: Vec<i32>) -> i32 {
+        let mut max_area = 0;
+        let (mut left, mut right) = (0, height.len() - 1);
+        while left < right {
+            let width = (right - left) as i32;
+            let min_height = height[left].min(height[right]);
+            let area = width * min_height;
+            max_area = max_area.max(area);
+            if height[left] < height[right] {
+                left += 1;
+            } else {
+                right -= 1;
+            }
+        }
+        max_area
+    }
+}

container-with-most-water/gcount85.py

@@ -0,0 +1,24 @@
+"""
+# Approach
+투포인터로 양 끝에서 물의 양을 계산해나갑니다.
+더 낮은 height인 쪽의 포인터를 줄여나가는데, 높이가 같은 경우에는 왼쪽 포인터만 움직입니다.
+
+# Complexity
+height의 길이가 N일 때
+- Time complexity: O(N)
+- Space complexity: O(1)
+"""
+
+
+class Solution:
+    def maxArea(self, height: list[int]) -> int:
+        n = len(height)
+        left, right = 0, n - 1
+        best = 0
+        while left < right:
+            best = max(best, (right - left) * min(height[left], height[right]))
+            if height[left] > height[right]:
+                right -= 1
+            else:
+                left += 1
+        return best

container-with-most-water/gyeo-ri.py

@@ -0,0 +1,51 @@
+"""
+[결과 요약]
+# 시도한 로직 수: 3
+    1. 모든 결과룰 순회하면서 시간복잡도 O(n^2)을 시도 -> LeetCode에서 Time Limit Exceed 발생
+    2. 리스트 양쪽 끝에서 포인터를 이동하는 알고리즘: 시간/공간 모두 O(n)
+    3. (2)의 로직은 유지한 채로 코드 가독성을 개선(알고리즘의 흐름을 쉽게 이해할 수 있도록)
+"""
+
+
+class Solution:
+    def maxArea(self, height: list[int]) -> int:
+        left, right = 0, len(height) - 1
+        max_area = 0
+
+        while left < right:
+            left_height, right_height = height[left], height[right]
+            min_height = min(left_height, right_height)
+            width = right - left
+
+            current_area = width * min_height
+            max_area = max(max_area, current_area)
+
+            if left_height < right_height:
+                left += 1
+            else:
+                right -= 1
+
+        return max_area
+
+
+if __name__ == "__main__":
+    test_cases = [
+        ([1, 1], 1),
+        ([1, 2, 1], 2),
+        ([4, 3, 2, 1, 4], 16),
+        ([1, 8, 6, 2, 5, 4, 8, 3, 7], 49),
+        ([1, 2, 4, 3], 4),
+        ([2, 3, 10, 5, 7, 8, 9], 36),
+        ([1, 3, 2, 5, 25, 24, 5], 24),
+        ([5, 5, 5, 5, 5], 20),
+        ([1, 1000, 1, 1000, 1], 2000),
+        ([1, 2, 3, 4, 5, 6], 9),
+    ]
+
+    solution = Solution()
+    for idx, case_ in enumerate(test_cases):
+        height, answer = case_
+        result = solution.maxArea(height)
+        assert (
+            answer == result
+        ), f"Test Case {idx + 1} Failed: Expected {answer}, Got {result}"

container-with-most-water/hwi-middle.cpp

@@ -0,0 +1,30 @@
+class Solution {
+public:
+    int maxArea(vector<int>& height) {
+        int l = 0;
+        int r = height.size() - 1;
+
+        int area = 0;
+
+        // 투 포인터로 접근
+        while (l < r)
+        {
+            // 너비(물 저장량)를 구하고 최댓값 업데이트
+            area = max(area, (r - l) * min(height[r], height[l]));
+
+            // 높이가 낮은 쪽의 커서를 이동
+            // -> 높은 쪽의 커서를 움직이면 무조건 손해
+            // -> 너비는 줄어들고 높이까지 줄어드니까
+            if (height[l] < height[r])
+            {
+                l++;
+            }
+            else
+            {
+                r--;
+            }
+        }
+
+        return area;
+    }
+};

container-with-most-water/hyejj19.ts

@@ -0,0 +1,23 @@
+function maxArea(height: number[]): number {
+  let left = 0;
+  let right = height.length - 1;
+  let max = -1;
+
+  while (right > left) {
+    const v = Math.min(height[left], height[right]) * (right - left);
+    max = Math.max(max, v);
+    if (height[left] >= height[right]) {
+      right--;
+    } else {
+      left++;
+    }
+  }
+  return max;
+}
+
+/*
+1. Math.min(height[left], height[right]) * (right - left);
+2. left 와 right 를 양 끝에서 가리킴
+3. 너비를 계산해서 max 값을 갱신하고, 둘 중 더 짧은 쪽을 안쪽으로 이동
+4. left 와 right 가 만나면 종료
+ */

container-with-most-water/hyeri0903.py

@@ -0,0 +1,32 @@
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        '''
+        1.문제: 가장 많은 양의 물을 저장할 수 있는 max value return
+        2.조건
+        - n: 높이를 의미, 최소 = 5, 최대 = 10^5
+        - 원소값 최소 = 0, 최대 = 10^4
+        3.풀이
+        - 높이는 height[i], height[j] 중에 작은 값, 가로는 abs(i-j)
+        - output = 높이 x 가로
+        -> 2중 loop 는 O(n^2) 로 TLE 발생.
+        -> two pointer 로 O(n) 으로 해결!
+        '''
+
+        n = len(height)
+        maxArea = 0
+
+        left = 0
+        right = n-1
+
+        while left < right:
+            curArea = abs(right-left) * min(height[left], height[right])
+            maxArea = max(curArea, maxArea)
+            
+            #height 이 낮은쪽 pointer update
+            if height[left] < height[right]:
+                left += 1
+            else:
+                right -= 1
+        
+        return maxArea
+        

container-with-most-water/kangdaia.py

@@ -0,0 +1,15 @@
+class Solution:
+    def maxArea(self, height: list[int]) -> int:
+        # 가장 멀리 떨어져 있으면서 높이가 비슷한 막대기?
+        max_area = 0
+        i, j = 0, len(height) - 1
+        while i < j:
+            left, right = height[i], height[j]
+            area = min(left, right) * (j - i)
+            if area > max_area:
+                max_area = area
+            if left < right:
+                i += 1
+            else:
+                j -= 1
+        return max_area

container-with-most-water/liza0525.py

@@ -29,3 +29,36 @@ def maxArea(self, height: List[int]) -> int:
             )
 
         return result_area
+
+
+# 7기 풀이
+# 시간 복잡도: O(n)
+# - two point 알고리즘을 이용하기 때문에 heights 변수의 길이인 n에 시간복잡도가 정해짐
+# 공간 복잡도: O(1)
+# - 몇 개의 변수만 사용함
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        # 양 끝 포인터 지정
+        start, end = 0, len(height) - 1
+
+        # max_area는 현재 포인터들을 이용했을 때의 넓이 계산
+        # 이때 높이는 작은 쪽으로 선택하여 계산해야 함
+        max_area = min(height[start], height[end]) * (end - start)
+
+        # start가 end보다 작을 때 루프 돌기
+        while start < end:
+            # 문제의 핵심 아이디어는, 높이가 큰 쪽을 움직이면 얻을 수 있는 최선이 현재보다 클 수 없다.
+            # 이는, start의 높이와 end의 높이 중 큰 쪽의 포인터를 고정하여 움직여야 한다는 것
+            # (물의 높이는 작은 쪽에 의해 정해지는데, 큰 쪽 포인터를 움직이면 x 길이만 짧아지게 되어 오히려 넓이이 줄어듦)
+            if height[start] < height[end]:
+                # start 쪽의 높이가 낮으면 start를 움직임
+                start += 1
+            else:
+                # end 쪽의 높이가 낮으면 end를 움직임
+                end -= 1
+
+            # 포인터를 옮기고 난 후의 넓이를 계산하여, 기존의 max_area와 비교하여 큰 쪽으로 업데이트
+            curr_area = min(height[start], height[end]) * (end - start)
+            max_area = max(max_area, curr_area)
+        
+        return max_area