Merge branch 'DaleStudy:main' into main

Author: gyeo-ri

3sum/gcount85.py 3sum/jamiebase.py3sum/gcount85.py renamed to 3sum/jamiebase.py

@@ -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/Cyjin-jani.js

@@ -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/Hyeri1ee.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/dohyeon2.java

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

@@ -0,0 +1,26 @@
+function maxProfit(prices: number[]): number {
+  let minPrice = Number.MAX_SAFE_INTEGER;
+  let maxProfit = 0;
+
+  for (let p of prices) {
+    if (minPrice >= p) {
+      minPrice = p;
+      continue;
+    } else {
+      let profit = p - minPrice;
+      if (profit > maxProfit) maxProfit = profit;
+    }
+  }
+  return maxProfit;
+}
+
+function maxProfit(prices: number[]): number {
+  let minPrice = Infinity;
+  let maxProfit = 0;
+
+  for (let p of prices) {
+    minPrice = Math.min(minPrice, p);
+    maxProfit = Math.max(maxProfit, p - minPrice);
+  }
+  return maxProfit;
+}

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

@@ -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/hyeri0903.java

@@ -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/jamiebase.py

@@ -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/juhui-jeong.java

@@ -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
+    
+};
+