Merge branch 'DaleStudy:main' into main

Author: jamiebase

best-time-to-buy-and-sell-stock/Hyeri1ee.java

@@ -0,0 +1,41 @@
+class Solution {
+
+  
+   
+
+
+    //O(n)에 증가 한 경우 profitMax를 갱신시키며 판단 -> time limit
+    public int maxProfit(int[] prices) {
+        int profitMax = 0;
+        /*
+        for(int i=0; i< prices.length - 1; i++){
+            int buy= prices[i];
+        
+
+            for(int d =i+1; d < prices.length; d++){
+                int sellCandid = prices[d];
+                if (sellCandid - buy > profitMax){
+                    profitMax = sellCandid - buy;
+                }
+
+            }
+        }//end of for
+
+        */
+
+        int priceMin = Integer.MAX_VALUE;
+        for(int i =0; i < prices.length; i++){
+            if (prices[i] < priceMin){
+                priceMin = prices[i];
+            }
+            else{
+                profitMax = Math.max(profitMax, prices[i] - priceMin);
+            }
+        }
+
+        return profitMax; 
+        
+    }
+    
+}
+

best-time-to-buy-and-sell-stock/dohyeon2.java

@@ -0,0 +1,24 @@
+class Solution {
+    // TC : O(n)
+    // SC : O(1)
+    public int maxProfit(int[] prices) {
+        int maximumProfit = 0;
+        int cursor = 0;
+
+        // 전체를 순회하면서 이익을 검증
+        for(int i = 0; i < prices.length; i++){
+            int profit = prices[i] - prices[cursor];
+
+            // 만약 현재 값이 커서의 값보다 더 작다면 현재 값부터 비교하기 시작
+            if(profit < 0){
+                cursor = i;
+                continue;
+            }
+
+            // 이전에 커서로 추정한 값이 높더라도 Math.max로 보존됨
+            maximumProfit = Math.max(profit, maximumProfit);
+        }
+
+        return maximumProfit;
+    }
+}

best-time-to-buy-and-sell-stock/gyeo-ri.py

@@ -0,0 +1,39 @@
+"""
+[결과 요약]
+# 시도한 로직 수: 2
+    1. if/else 문으로 분기 처리(시간: O(n) / 공간: O(1))
+        -
+    2. if문 대신 min / max를 계속 계산하는 로식
+        - None 대신 float(inf)를 사용하여 None 검증 분기 제거
+        - inf 사용을 위해서 마지막 return에 int() 타입 변환 필요
+        - 성능은 1과 큰 차이 없으며 코드가 간소화
+"""
+
+
+class Solution:
+    def maxProfit(self, prices: list[int]) -> int:
+        max_profit = 0
+        min_price = float("inf")
+
+        for p in prices:
+            min_price = min(min_price, p)
+            max_profit = max(max_profit, p - min_price)
+
+        return int(max_profit)
+
+
+if __name__ == "__main__":
+    test_cases = [
+        ([7, 1, 5, 3, 6, 4], 5),
+        ([7, 6, 4, 3, 1], 0),
+        ([2, 4, 1], 2),
+        ([1, 2, 4, 10000, 2, 1, 3], 9999),
+    ]
+
+    solution = Solution()
+    for idx, case_ in enumerate(test_cases):
+        prices, answer = case_
+        result = solution.maxProfit(prices)
+        assert (
+            answer == result
+        ), f"Test Case {idx} Failed: Expected {answer}, Got {result}"

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

best-time-to-buy-and-sell-stock/robinyoon-dev.js

@@ -23,7 +23,6 @@ var maxProfit = function (prices) {
     return maxProfit;
 };
 
-
 // -----아래는 이전에 작성한 답안입니다.
 // /**
 //  * @param {number[]} prices

best-time-to-buy-and-sell-stock/sangbeenmoon.py

@@ -0,0 +1,13 @@
+# TC : O(n)
+# SC : O(1)
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        answer = 0
+        mm = 10001
+
+        for price in prices:
+            mm = min(mm, price)
+            answer = max(answer, price - mm)
+        
+        return answer

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

@@ -1,14 +1,16 @@
+// 3rd tried
 function maxProfit(prices: number[]): number {
-  let minPrice = Infinity;
-  let maxProfit = 0;
-  for (let i = 0; i < prices.length; i++) {
-    if (prices[i] < minPrice) {
-      minPrice = prices[i];
-    }
+  let left = 0;
+  let right = 1;
+  let max = 0;
 
-    if (prices[i] - minPrice > maxProfit) {
-      maxProfit = prices[i] - minPrice;
-    }
+  while(left < right && right < prices.length) {
+      if(prices[right] - prices[left] > 0) {
+          max = Math.max(max, prices[right] - prices[left])
+      } else {
+          left = right;
+      }
+      right++;
   }
-  return maxProfit;
-}
+  return max;
+};

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

@@ -1,7 +1,7 @@
 """
 # Approach
 투포인터로 양 끝에서 물의 양을 계산해나갑니다.
-더 낮은 height인 쪽의 포인터를 줄여나가는데, 높이가 같은 경우에는 양쪽 모두 포인터를 움직입니다.
+더 낮은 height인 쪽의 포인터를 줄여나가는데, 높이가 같은 경우에는 왼쪽 포인터만 움직입니다.
 
 # Complexity
 height의 길이가 N일 때