Merge branch 'main' of https://github.com/printjin-gmailcom/Dalle_Code-Leetcode_Study

Author: printjin-gmailcom

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

@@ -0,0 +1,40 @@
+/**
+ * [Problem]: [121] Best Time to Buy and Sell Stock
+ *
+ * (https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/)
+ */
+function maxProfit(prices: number[]): number {
+    //시간복잡도: O(n^2);
+    //공간복잡도: O(1);
+    // Time Limit Exceeded
+    function doublyLoopFunc(prices: number[]): number {
+        let result = 0;
+        for (let i = 0; i < prices.length; i++) {
+            for (let j = i + 1; j < prices.length; j++) {
+                let profit = prices[j] - prices[i];
+                result = Math.max(profit, result);
+            }
+        }
+
+        return result;
+    }
+
+    // 시간 복잡도: O(n)
+    // 공간 복잡도: O(1)
+    function twoPointerFunc(prices: number[]): number {
+        let minPrice = prices[0];
+        let maxProfit = 0;
+
+        for (let i = 1; i < prices.length; i++) {
+            if (prices[i] < minPrice) {
+                minPrice = prices[i];
+            } else {
+                maxProfit = Math.max(maxProfit, prices[i] - minPrice);
+            }
+        }
+
+        return maxProfit;
+    }
+
+    return twoPointerFunc(prices);
+}

best-time-to-buy-and-sell-stock/JANGSEYEONG.js

@@ -0,0 +1,22 @@
+/**
+ * 시간 복잡도: O(n) - 배열을 한 번만 순회함
+ * 공간 복잡도: O(1) - 추가 배열 없이 변수만 사용하므로 입력 크기와 무관한 상수 공간
+ */
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function (prices) {
+  let minPrice = prices[0]; // 지금까지 본 가장 낮은 가격
+  let maxProfit = 0; // 최대 이익
+  for (let i = 1; i < prices.length; i++) {
+    if (prices[i] > minPrice) {
+      // 현재 가격이 minPrice보다 큰 경우에 이익 갱신
+      maxProfit = Math.max(maxProfit, prices[i] - minPrice);
+    } else {
+      // 그렇지 않다면 최소 가격 갱신
+      minPrice = prices[i];
+    }
+  }
+  return maxProfit;
+};

best-time-to-buy-and-sell-stock/PDKhan.cpp

@@ -0,0 +1,16 @@
+class Solution {
+    public:
+        int maxProfit(vector<int>& prices) {
+            int min = INT_MAX;
+            int profit = 0;
+    
+            for(int i = 0; i < prices.size(); i++){
+                if(prices[i] < min)
+                    min = prices[i];
+                
+                profit = max(profit, prices[i] - min);
+            }
+    
+            return profit;
+        }
+    };

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

@@ -0,0 +1,33 @@
+/**
+ * 주식 가격이 주어지는 prices 배열이 있을 때 최대 주식 이익을 구하시오
+ * 주식을 산 날짜에는 팔 수 없으며 반드시 산 날짜의 이후 날짜부터(미래부터) 팔 수 있다.
+ */
+class Solution {
+    public int maxProfit(int[] prices) {
+        int maxProfit = 0;
+        int min = prices[0];
+        // 굳이 DP 배열 쓰지 않고 계산, 공간 복잡도 낮추기
+        for (int i = 0; i < prices.length; i++) {
+            int profit = prices[i] - min;
+            maxProfit = Math.max(profit, maxProfit);
+            min = Math.min(prices[i], min);
+        }
+        return maxProfit;
+    }
+
+    // public int maxProfit(int[] prices) {
+    //     // 최저 구매
+    //     int[] dp = new int[prices.length];
+    //     dp[0] = prices[0];
+    //     for (int i = 1; i < prices.length; i++) {
+    //         dp[i] = Math.min(prices[i], dp[i - 1]);            
+    //     }
+    //     // 최저 구매 배열 기준으로 당일 최대 이익 계산
+    //     int profit = 0;
+    //     for (int i = 1; i < prices.length; i++) {
+    //         profit = Math.max(prices[i] - dp[i - 1], profit);
+    //     }
+    //     return profit;
+    // }
+}
+

best-time-to-buy-and-sell-stock/Yn3-3xh.java

@@ -0,0 +1,19 @@
+/**
+[문제풀이]
+- 작은수를 두고, 큰수에 뺀 값을 구하자.
+time: O(N), space: O(1)
+
+[회고]
+이번 문제는 난이도가 easy인 덕분에 무리없이 풀었던 것 같다.
+ */
+class Solution {
+    public int maxProfit(int[] prices) {
+        int min = prices[0];
+        int max = 0;
+        for (int i = 1; i < prices.length; i++) {
+            min = Math.min(min, prices[i]);
+            max = Math.max(max, prices[i] - min);
+        }
+        return max;
+    }
+}

best-time-to-buy-and-sell-stock/byol-han.js

@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function (prices) {
+  let minPrice = Infinity;
+  let maxProfit = 0;
+
+  for (let i = 0; i < prices.length; i++) {
+    if (prices[i] < minPrice) {
+      minPrice = prices[i]; // 지금까지 가장 싼 날
+    } else if (prices[i] - minPrice > maxProfit) {
+      maxProfit = prices[i] - minPrice; // 현재 이익이 최대 이익보다 클 때 maxProfit 갱신
+    }
+  }
+
+  return maxProfit;
+};

best-time-to-buy-and-sell-stock/clara-shin.js

@@ -0,0 +1,24 @@
+/**
+ * 시간 복잡도 O(n)
+ * 공간 복잡도 O(1)
+ *
+ * 그리디 알고리즘
+ * 현재까지의 최저 가격을 기억하고, 그 가격에 샀을 때의 이익을 계속 계산하여 최대 이익을 구함
+ */
+
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function (prices) {
+  let minPrice = prices[0]; // 최저 가격 초기화 (첫 날 가격)
+  let maxProfit = 0; // 최대 이익 초기화 (아직 이익 없음)
+
+  // 두 번째 날부터
+  for (let i = 1; i < prices.length; i++) {
+    minPrice = Math.min(minPrice, prices[i]); // 최저 가격 갱신
+    maxProfit = Math.max(maxProfit, prices[i] - minPrice); // 최대 이익 갱신
+  }
+
+  return maxProfit;
+};

best-time-to-buy-and-sell-stock/doitduri.swift

@@ -0,0 +1,18 @@
+class Solution {
+    func maxProfit(_ prices: [Int]) -> Int {
+        guard var anchor = prices.first, prices.count > 1 else {
+            return 0
+        }
+        
+        var result = 0
+        for price in prices {
+            if price < anchor {
+                anchor = price
+            } else if price - anchor > result {
+                result = price - anchor
+            }
+        }
+        
+        return result
+    }
+}

best-time-to-buy-and-sell-stock/hsskey.js

@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function(prices) {
+    let buy = prices[0]
+    let maxVal = 0
+
+    for(let i = 1; i < prices.length; i++) {
+        if(prices[i - 1] > prices[i]) {
+            buy = Math.min(buy, prices[i])
+        }
+
+        if(prices[i - 1] < prices[i]) {
+            maxVal = Math.max(maxVal, prices[i] - buy)
+        }
+    }
+    return maxVal
+};

best-time-to-buy-and-sell-stock/i-mprovising.py

@@ -0,0 +1,16 @@
+"""
+Time complexity O(n)
+Space complexity O(1)
+
+Dynamic programming
+"""
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        max_profit = 0
+        min_price = prices[0]
+        for p in prices:
+            max_profit = max(max_profit, p - min_price)
+            min_price = min(min_price, p)
+
+        return max_profit

best-time-to-buy-and-sell-stock/jiji-hoon96.ts

@@ -0,0 +1,23 @@
+function maxProfit(prices: number[]): number {
+  if (prices.length <= 1) return 0;
+  
+  let minPrice = prices[0];
+  let maxProfit = 0;
+  
+  for (let i = 1; i < prices.length; i++) {
+      // 현재 가격이 최소가보다 낮으면 최소가 업데이트
+      if (prices[i] < minPrice) {
+          minPrice = prices[i];
+      } 
+      // 현재 가격으로 팔았을 때의 이익 계산
+      else {
+          const currentProfit = prices[i] - minPrice;
+          // 최대 이익 업데이트
+          if (currentProfit > maxProfit) {
+              maxProfit = currentProfit;
+          }
+      }
+  }
+  
+  return maxProfit;
+}

best-time-to-buy-and-sell-stock/minji-go.java

@@ -0,0 +1,18 @@
+/**
+ * <a href="https://leetcode.com/problems/best-time-to-buy-and-sell-stock/">week05-1.best-time-to-buy-and-sell-stock</a>
+ * <li>Description: Return the maximum profit you can achieve from this transaction</li>
+ * <li>Topics: Array, Dynamic Programming       </li>
+ * <li>Time Complexity: O(N), Runtime 2ms       </li>
+ * <li>Space Complexity: O(1), Memory 61.62MB   </li>
+ */
+class Solution {
+    public int maxProfit(int[] prices) {
+        int min = prices[0];
+        int profit = 0;
+        for(int i=1; i<prices.length; i++) {
+            profit = Math.max(profit, prices[i]-min);
+            min = Math.min(min, prices[i]);
+        }
+        return profit;
+    }
+}

best-time-to-buy-and-sell-stock/moonjonghoo.js

@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function (prices) {
+  let minPrices = Infinity;
+  let profit = 0;
+  for (price of prices) {
+    minPrices = Math.min(price, minPrices);
+    profit = Math.max(profit, price - minPrices);
+  }
+  return profit;
+};
+
+var maxProfit = function (prices) {
+  let maxProfit = 0;
+  let currentProfit = 0;
+  for (let i = 1; i < prices.length; i++) {
+    let diff = prices[i] - prices[i - 1];
+    currentProfit = Math.max(0, currentProfit + diff);
+    maxProfit = Math.max(maxProfit, currentProfit);
+  }
+  return maxProfit;
+};

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

@@ -0,0 +1,26 @@
+class Solution(object):
+    def maxProfit(self, prices):
+        """
+        :type prices: List[int]
+        :rtype: int
+        주어진 prices를 한 번만 순회하면서
+        지금까지의 최솟값을 추적하고, 
+        '현재 가격 - 지금까지의 최솟값'으로 계산되는 이익이
+        '지금까지의 최대 이익(초기 0)보다 크면 갱신하여 
+        최종 최대 이익 구하기 문제
+        Time Complexity: O(n)
+        Space Complexity: O(1)
+        """
+        max_profit = 0 # 이익이 없을 때 0을 반환하게 초기화
+        min_price = float('inf') # 최소 가격 저장, 무한대로 초기화해서 루프 첫 번째 가격부터 최소 가격에 저장
+
+        for price in prices:
+            # 최대 이익 갱신
+            max_profit = max(max_profit, (price - min_price))
+            # 최소 가격 갱신
+            min_price = min(min_price, price)
+            # 최대 이익(max_profit) 갱신 이후 최소 가격(min_price) 갱신해야 함
+            # 최대 이익 자체는 이미 '산' 주식에 대해 계산해야 하므로
+            # 사는 동시 팔 수 없음
+
+        return max_profit

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

@@ -0,0 +1,48 @@
+# https://leetcode.com/problems/best-time-to-buy-and-sell-stock/
+
+from typing import List
+
+class Solution:
+    def maxProfit1(self, prices: List[int]) -> int:
+        """
+        [Complexity]
+            - TC: O(n)
+            - SC: O(1)
+
+        [Approach]
+            prices를 순회하면서 다음을 트래킹하면 된다.
+                (1) 지금까지의 최소 가격인 min_price 트래킹:    min(min_price, price)
+                (2) 지금까지의 최대 수익인 max_profit 트래킹:   max(max_profit, price - min_price)
+        """
+        max_profit, min_price = 0, prices[0]
+
+        for price in prices:
+            min_price = min(min_price, price)
+            max_profit = max(max_profit, price - min_price)
+
+        return max_profit
+
+    def maxProfit(self, prices: List[int]) -> int:
+        """
+        [Complexity]
+            - TC: O(n)
+            - SC: O(1)
+
+        [Approach]
+            two-pointer(buy, sell)로도 접근 가능하다.
+            두 개의 pointer buy와 sell을 0, 1 인덱스에서 시작한 후, sell을 움직여가며 curr_profit = prices[sell] - prices[buy]를 구한다.
+            그리고 curr_profit이 0보다 크면 max_profit을 트래킹하고, 그렇지 않으면 buy를 sell 위치로 당긴다.
+            (curr_profit이 0보다 크지 않다는 것은, buy 시점의 price 이하인 price가 sell 시점에서 발견되었다는 뜻이다!)
+        """
+        buy, sell = 0, 1
+        max_profit = 0
+
+        while sell < len(prices):
+            curr_profit = prices[sell] - prices[buy]
+            if curr_profit > 0:
+                max_profit = max(max_profit, curr_profit)
+            else:
+                buy = sell
+            sell += 1
+
+        return max_profit

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

@@ -0,0 +1,17 @@
+class Solution {
+    public int maxProfit(int[] prices) {
+        int minPrice = prices[0];
+        int maxProfit = 0;
+
+        for(int p : prices){
+            if(minPrice < p && maxProfit < p - minPrice){
+                maxProfit = p - minPrice;
+            }
+            if(minPrice > p){
+                minPrice = p;
+            }
+        }
+        return maxProfit;
+    }
+}
+