Merge remote-tracking branch 'origin/main'

Author: chordpli

3sum/sora0319.java

@@ -35,3 +35,4 @@ public List<List<Integer>> threeSum(int[] nums) {
     }
 }
 
+

best-time-to-buy-and-sell-stock/DaleSeo.rs

@@ -0,0 +1,17 @@
+// TC: O(n)
+// SC: O(1)
+impl Solution {
+    pub fn max_profit(prices: Vec<i32>) -> i32 {
+        let mut min_price = i32::MAX;
+        let mut max_profit = 0;
+        for price in prices {
+            if price < min_price {
+                min_price = price;
+            }
+            if price - min_price > max_profit {
+                max_profit = price - min_price;
+            }
+        }
+        max_profit
+    }
+}

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

@@ -0,0 +1,21 @@
+function maxProfit(prices: number[]): number {
+
+        // Runtime: 1ms
+        // Memory: 66.23MB
+        let minPrice: number = prices[0];
+        let maxProfit: number = 0;
+
+        for (let i = 1; i < prices.length; i++) {
+    // 1. compare the number later than now
+            if (prices[i] < minPrice) {
+    // 2. if there's bigger number later, set it as the standard
+                minPrice = prices[i];
+            } else {
+                maxProfit = Math.max(maxProfit, prices[i] - minPrice);
+            }
+        }
+        return maxProfit;
+
+        // What I was planning to do: Recursion
+        // Result: referring other's code
+};

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

@@ -0,0 +1,12 @@
+class Solution {
+    func maxProfit(_ prices: [Int]) -> Int {
+        var lowPrice: Int = prices[0]
+        var maxProfit: Int = 0
+        for i in 0..<prices.endIndex {
+            lowPrice = min(lowPrice, prices[i])
+            maxProfit = max(maxProfit, prices[i] - lowPrice)
+        }
+        return maxProfit
+    }
+}
+ 

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

@@ -0,0 +1,16 @@
+# time complexity : O(n)
+# space complexity : O(1)
+from typing import List
+
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        n = len(prices)
+        min_price = prices[0]
+        max_profit = 0
+
+        for i in range(1, n):
+            min_price = min(min_price, prices[i])
+            max_profit = max(max_profit, prices[i] - min_price)
+
+        return max_profit

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

@@ -0,0 +1,16 @@
+var maxProfit = function (prices) {
+  let minPrice = Infinity;
+  let maxProfit = 0;
+
+  for (let price of prices) {
+    // 가장 싼 가격을 갱신
+    if (price < minPrice) {
+      minPrice = price;
+    } else {
+      // 최대 이익을 갱신
+      maxProfit = Math.max(maxProfit, price - minPrice);
+    }
+  }
+
+  return maxProfit;
+};

best-time-to-buy-and-sell-stock/hi-rachel.py

@@ -1,13 +1,26 @@
-# TC: O(N), SC: O(1)
+"""
+https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/
+
+You are given an array prices where prices[i] is the price of a given stock on the ith day.
+
+You want to maximize your profit by choosing a single day to buy one stock and choosing a different day in the future to sell that stock.
+
+Return the maximum profit you can achieve from this transaction. If you cannot achieve any profit, return 0.
+
+TC: O(N), SC: O(1)
+"""
+
+from typing import List
 
 class Solution:
     def maxProfit(self, prices: List[int]) -> int:
         max_profit = 0
         min_price = prices[0]
 
         for price in prices:
-            max_profit = max(price - min_price, max_profit)
             min_price = min(price, min_price)
+            max_profit = max(price - min_price, max_profit)
+        
         return max_profit
 
 # TS 풀이

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

@@ -0,0 +1,29 @@
+'''
+time complexity : O(n)
+space complexity : O(2n)
+
+Algorithm : dp
+주식 보유하는 경우:
+- 이전에 이미 보유 : hold[i - 1]
+- i번째 날 새로 사는 경우 : -prices[i]
+
+주식을 팔았을 떄:
+- 이전에 이미 팜 : sold[i - 1]
+- i번째 날 파는 경우 : hold[i-1] + prices[i]
+'''
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        if not prices or len(prices) < 2:
+            return 0
+        n = len(prices)
+        hold = [0] * n
+        sold = [0] * n
+
+        hold[0] = -prices[0]
+        sold[0] = 0
+
+        for i in range(1, n):
+            hold[i] = max(hold[i - 1], -prices[i])
+            sold[i] = max(sold[i - 1], hold[i - 1] + prices[i])
+        return sold[n - 1]

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

@@ -0,0 +1,25 @@
+class Solution:
+    """
+    1. 브루트포스
+    2중 for문이라서 O(n^2)임.
+    prices의 길이가 10^5이므로 10^10이 되면서 시간초과가 발생
+
+    2. 이분탐색으로 가능할까 했지만 DP를 사용해야 하는 문제 같음
+    시간복잡도는 O(n)이 나옴
+    """
+    """
+    def maxProfit(self, prices: List[int]) -> int:
+        max_profit = 0
+        for i in range(len(prices)-1):
+            for j in range(i, len(prices)):
+                profit = prices[j] - prices[i]
+                max_profit = max(max_profit, profit)
+        return max_profit
+    """
+    def maxProfit(self, prices: List[int]) -> int:
+        max_profit = 0
+        min_price = prices[0]
+        for price in prices:
+            max_profit = max(max_profit, price - min_price)
+            min_price = min(price, min_price)
+        return max_profit

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

@@ -0,0 +1,14 @@
+function maxProfit(prices: number[]): number {
+  let minPrice = Infinity;
+  let maxProfit = 0;
+
+  for (const price of prices) {
+    if (price < minPrice) {
+      minPrice = price;
+    } else {
+      maxProfit = Math.max(maxProfit, price - minPrice);
+    }
+  }
+
+  return maxProfit;
+}