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