Merge branch 'DaleStudy:main' into main

Author: nowrobin

best-time-to-buy-and-sell-stock/Cyjin-jani.js

@@ -0,0 +1,43 @@
+// naive하게 풀면, time limit 초과함
+// O(n^2) 풀이가 되기 때문..
+const maxProfit_naive = function (prices) {
+  let profit = 0;
+
+  for (let i = 0; i < prices.length - 1; i++) {
+    const buy = prices[i];
+    for (let j = i + 1; j < prices.length; j++) {
+      const newProfit = prices[j] - buy;
+      if (newProfit > profit) {
+        profit = newProfit;
+      }
+    }
+  }
+
+  return profit;
+};
+
+// 투포인터 사용하여 풀기
+// tc: O(n)
+// sc: O(1)
+const maxProfit = function (prices) {
+  let buyIdx = 0;
+  let sellIdx = 1;
+  let profit = 0;
+
+  while (sellIdx < prices.length) {
+    let buyPrice = prices[buyIdx];
+    let sellPrice = prices[sellIdx];
+
+    // 더 낮은 가격에 매수 가능한 날을 찾으면 바로 거기서부터 재탐색
+    if (buyPrice > sellPrice) {
+      buyIdx = sellIdx;
+    } else {
+      let newProfit = sellPrice - buyPrice;
+      profit = Math.max(profit, newProfit);
+    }
+
+    sellIdx++;
+  }
+
+  return profit;
+};

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/gcount85.py

@@ -0,0 +1,21 @@
+"""
+# Approach
+지금까지의 최저 가격을 갱신함과 동시에 최선의 이익도 업데이트합니다.
+
+# Complexity
+- Time complexity: O(N)
+
+- Space complexity: O(1)
+"""
+
+
+class Solution:
+    def maxProfit(self, prices: list[int]) -> int:
+        min_price = float("inf")
+        answer = 0
+
+        for price in prices:
+            min_price = min(min_price, price)
+            answer = max(answer, price - min_price)
+
+        return answer

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/hwi-middle.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int maxProfit(vector<int>& prices) {
+        int res = 0;
+        int minPrice = prices[0];
+        int len = prices.size();
+        for (int i = 0; i < len; ++i)
+        {
+            res = max(res, prices[i] - minPrice); // 수익 최대화: 지금까지 가장 쌌던 날에 사서 오늘 팔기
+            minPrice = min(minPrice, prices[i]); // '지금까지 가장 쌌던 날' 업데이트
+        }
+
+        return res;
+    }
+};

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

@@ -0,0 +1,43 @@
+class Solution {
+    public int maxProfit(int[] prices) {
+        /**
+        1. 하루에 팔아서 가장 최대 이익을 구하도록하는 max price return
+        2. 조건
+        - 미래 다른날짜에 판매 (이전 날짜에 판매 x)
+        - choosing a single day
+        - 배열 길이 min = 1, max = 10^5
+        - 원소값 : min = 0, max = 10^4
+        3. 풀이
+        - 1)brtueforce: time complexity O(n^2), space: O(1)
+        - 2)현재 값 - 이전 값 중 가장 최소값 -> maxProfit , 즉 min값을 계속 기억하다가 현재 값과의 차이 중 가장 큰 값을 구하면된다.
+        - time: O(n)
+        - space: O(1)
+         */
+
+        int maxProfit = 0;
+        int minStock = Integer.MAX_VALUE;
+        int n = prices.length;
+
+        for(int i = 0; i<n; i++) {
+            if(prices[i] < minStock) {
+                minStock = prices[i];
+            }
+            if(i > 0 && prices[i] - minStock > maxProfit) {
+                maxProfit = Math.max(maxProfit, prices[i] - minStock);
+            }
+        }
+        return maxProfit;
+
+
+        // for(int i = 0; i < n; i++) {
+        //     int curStock = prices[i];
+        //     for(int j= i + 1; j < n; j++) {
+        //         if(curStock < prices[j]) {
+        //             int curProfit = prices[j] - curStock;
+        //             maxProfit = Math.max(maxProfit, curProfit);
+        //         }
+        //     }
+        // }
+        // return maxProfit;
+    }
+}

best-time-to-buy-and-sell-stock/juhui-jeong.java

@@ -0,0 +1,34 @@
+/*
+시간복잡도: O(n²)
+공간복잡도: O(1)
+class Solution {
+    public int maxProfit(int[] prices) {
+        int maxStock = 0;
+        for(int i = 0; i < prices.length; i++) {
+            for (int j = 0; j < prices.length; j++) {
+                if (i <= j) break;
+                if (prices[i] - prices[j] > maxStock) {
+                    maxStock = prices[i] - prices[j];
+                }
+            }
+        }
+        return maxStock;
+    }
+}
+ */
+// 시간복잡도: O(n)
+// 공간복잡도: O(1)
+class Solution {
+    public int maxProfit(int[] prices) {
+        int maxStock = 0;
+        int minPrice = prices[0];
+        for (int price : prices) {
+            if (price < minPrice) {
+                minPrice = price;
+            } else {
+                maxStock = Math.max(price - minPrice, maxStock);
+            }
+        }
+        return maxStock;
+    }
+}

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

@@ -0,0 +1,15 @@
+// TC: O(N)
+// SC: O(1)
+function maxProfit(prices: number[]): number {
+    let maxProfit = 0
+    let minPrice = Infinity
+
+    for(const price of prices) {
+        maxProfit = Math.max(price - minPrice, maxProfit)
+        minPrice = Math.min(price, minPrice)
+    }
+
+    return maxProfit
+    
+};
+

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

@@ -0,0 +1,27 @@
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        # When length is 1, no profit possible
+        if len(prices) == 1:
+            return 0
+
+        buy = 10 ** 5
+        profit = 0
+
+        # Iterate through prices
+        for price in prices:
+            # if price < buy:
+            #     buy = price
+
+            #     for j in range(i + 1, len(prices)):
+            #         if prices[j] <= buy:
+            #             continue
+
+            #         if prices[j] - buy > profit:
+            #             profit = prices[j] - buy
+            buy = min(buy, price)
+            profit = max(profit, price - buy)
+
+        return profit
+
+# Time Complexity: O(n)
+# Space Complexity: O(1)