Merge branch 'DaleStudy:main' into main

Author: Yjason-K

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

@@ -0,0 +1,40 @@
+"""
+Solution: 1) 2중 포문을 돌면서 max값을 구한다.
+Time: O(n^2)
+Space: O(1)
+
+Time Limit Exceeded
+
+"""
+
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        result = 0
+        for l in range(len(prices) - 1):
+            for r in range(l + 1, len(prices)):
+                result = max(result, prices[r] - prices[l])
+
+        return result
+
+
+"""
+Solution: 
+    1) prices를 순회하면서 max_profit 을 찾는다. 
+    2) profit 은 current price - min_profit로 구한다.
+Time: O(n)
+Space: O(1)
+"""
+
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        n = len(prices)
+        max_profit = 0
+        min_price = prices[0]
+
+        for i in range(1, len(prices)):
+            profit = prices[i] - min_price
+            max_profit = max(max_profit, profit)
+            min_price = min(prices[i], min_price)
+        return max_profit

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

@@ -0,0 +1,30 @@
+class Solution {
+    public int maxProfit(int[] prices) {
+        /**
+        1. understanding
+        - price[i]: i th day's stock price
+        - to maximize profit, choose a single day to buy, and future day to sell.
+        - return maximum profit
+        - [7, 1, 5, 3, 6, 4] -> [0, 0, 4, 4, 5, 5]
+        - [7, 6, 4, 3, 1] -> [0, 0, 0, 0, 0]
+        2. strategy
+        - profit = (sell price) - (buy price)
+        3. complexity
+        - time: O(N)
+        - space: O(1)
+        */
+        int minPrice = prices[0];
+        for (int i = 0; i <prices.length; i++) {
+            int tmp = prices[i];
+            if (i == 0) {
+                prices[i] = 0;
+            } else {
+                prices[i] = Math.max(prices[i-1], prices[i] - minPrice);
+            }
+            minPrice = Math.min(minPrice, tmp);
+        }
+
+        return prices[prices.length - 1];
+    }
+}
+

best-time-to-buy-and-sell-stock/Real-Reason.kt

@@ -0,0 +1,15 @@
+package leetcode_study
+
+import kotlin.math.max
+import kotlin.math.min
+fun maxProfit(prices: IntArray): Int {
+    var minPrice = prices[0]
+    var maxProfit = 0
+
+    for (i in 0 until prices.size) {
+        maxProfit = max(maxProfit, prices[i] - minPrice)
+        minPrice = min(minPrice, prices[i])
+    }
+
+    return maxProfit
+}

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

@@ -0,0 +1,19 @@
+/**
+ * 최대 수익을 구하는 알고리즘
+ * 알고리즘 복잡도
+ * - 시간 복잡도: O(n)
+ * - 공간 복잡도: O(1)
+ * @param prices
+ */
+function maxProfit(prices: number[]): number {
+    let min = prices[0]
+    let total = 0
+
+    for(let i = 1 ; i < prices.length ; i++) {
+        min = Math.min(min, prices[i])
+        // console.log(dp[i],'===', dp[i-1], '===', prices[i])
+        total = Math.max(total, prices[i] - min)
+    }
+
+    return total
+}

best-time-to-buy-and-sell-stock/bus710.go

@@ -0,0 +1,19 @@
+// https://leetcode.com/problems/best-time-to-buy-and-sell-stock/
+
+package hello
+
+func maxProfit(prices []int) int {
+	min := prices[0]
+	maxProfit := 0
+
+	for i := 1; i < len(prices); i++ {
+		if prices[i] < min {
+			min = prices[i]
+		}
+		if (prices[i] - min) > maxProfit {
+			maxProfit = prices[i] - min
+		}
+	}
+
+	return maxProfit
+}

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

@@ -0,0 +1,11 @@
+class Solution {
+  public int maxProfit(int[] prices) {
+    int minPrice = Integer.MAX_VALUE;
+    int maxProfit = 0;
+    for(int i = 0; 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/eunhwa99.java

@@ -0,0 +1,55 @@
+// 풀이 방법
+// 1. 인덱스 x까지의 최소값을 저장하는 배열 1개와, 인덱스 x부터의 최대값을 저장하는 배열 1개를 만든다.
+// 2. 1번에서 만든 두 배열에 값을 채운다.
+// 3. 두 배열을 각각 인덱스 별로 차를 구하고, 그 중 최댓값을 구한다.
+
+// 시간 복잡도
+// O(n) : 배열을 2번 순회하므로 O(n)이다.
+// 공간 복잡도
+// O(n) : 최소값과 최대값을 저장하는 배열을 만들었으므로 O(n)이다.
+
+class Solution {
+    public int maxProfit(int[] prices) {
+        int len = prices.length;
+        int[] minArr = new int[len];
+        int[] maxArr = new int[len];
+
+        for(int i=0;i<len;i++){
+            if(i==0){
+                minArr[i] = prices[i];
+                maxArr[len-i-1] = prices[len-i-1];
+            }else{
+                minArr[i] = Math.min(minArr[i-1], prices[i]);
+                maxArr[len-i-1] = Math.max(maxArr[len-i], prices[len-i-1]);
+            }
+        }
+
+        int result = 0;
+        for(int i=0;i<len;i++){
+            result = Math.max(result, maxArr[i]-minArr[i]);
+        }
+        return result;
+    }
+}
+
+
+// 2nd solution 
+// 시간 복잡도: O(n)
+// 공간 복잡도: O(1) 
+
+class Solution{
+    public int maxProfit(int[] prices){
+        int len = prices.length;
+        int buy = prices[0];
+        int result = 0;
+
+        for(int i=1;i<len;i++){
+            if(prices[i]<buy){ // 더 저렴한 주식이 있으므로
+                buy = prices[i]; // 이 주식을 산다.
+            }else{
+                result = Math.max(result, prices[i]-buy); // 현재 주식을 팔았을 때 이득이 더 크다면 판다.
+            }
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,30 @@
+/*
+Time complexity: O(n)
+Space complexity: O(1)
+
+i <= j 인 두 인덱스 i, j에 대해서, prices[j] - prices[i]를 최대화해야 한다.
+
+1. i = 0부터 시작하여, 오른쪽으로 순회한다.
+2. 현재 값이 max보다 크다면, max를 갱신하고, min과의 차이를 계산한다.
+3. 현재 값이 min보다 작다면, min을 갱신하고, max 역시 같은 값으로 갱신한다. (과거로 돌아가서 팔 수는 없으므로)
+*/
+class Solution {
+    public int maxProfit(int[] prices) {
+        int min = 999999;
+        int max = 0;
+        int ans = 0;
+        for (int i = 0; i < prices.length; i++) {
+            if (prices[i] > max) {
+                max = prices[i];
+                if (max - min > ans) {
+                    ans = max - min;
+                }
+            }
+            if (prices[i] < min) {
+                min = max = prices[i];
+            }
+        }
+
+        return ans;
+    }
+}

best-time-to-buy-and-sell-stock/gmlwls96.kt

@@ -0,0 +1,20 @@
+class Solution {
+    /**
+     * 시간 : O(n) 공간 : O(1)
+     * 풀이
+     *  lastIndex - 1부터 0까지 조회하면서 가장높은값(maxPrice) 에서 현재값(price[i])의 차(currentProfit)를 구한다.
+     *  profit 과 currentProfit중 더 높은값이 profit.
+     *  maxPrice와 prices[i]중 더 높은값이 maxPrice가 된다.
+     * */
+    fun maxProfit(prices: IntArray): Int {
+        var profit = 0
+        var maxPrice = prices[prices.lastIndex]
+        for (i in prices.lastIndex - 1 downTo 0) {
+            val currentProfit = maxPrice - prices[i]
+            profit = max(profit, currentProfit)
+            maxPrice = max(maxPrice, prices[i])
+        }
+
+        return profit
+    }
+}

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

@@ -0,0 +1,18 @@
+// Time complexity: O(n)
+// Space complexity: O(1)
+
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function (prices) {
+  let answer = 0;
+  let minValue = Number.MAX_SAFE_INTEGER;
+
+  for (const price of prices) {
+    minValue = Math.min(minValue, price);
+    answer = Math.max(answer, price - minValue);
+  }
+
+  return answer;
+};