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

Author: printjin-gmailcom

3sum/iam-edwin.java

@@ -0,0 +1,40 @@
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        List<List<Integer>> result = new ArrayList<>();
+
+        Map<Integer, Integer> counter = new HashMap<>();
+        for (int num : nums) {
+            int count = counter.getOrDefault(num, 0);
+            counter.put(num, count + 1);
+        }
+
+        Set<Integer> keySet = new HashSet<>(counter.keySet());
+        for (int num1 : keySet) {
+            int num1Count = counter.get(num1);
+            if (num1Count > 1) {
+                counter.put(num1, num1Count - 1);
+            } else {
+                counter.remove(num1);
+            }
+
+            for (int num2 : counter.keySet()) {
+                int num3 = -num1 - num2;
+                int count = counter.getOrDefault(num3, 0);
+                if (((num2 == num3 && count >= 2) || (num2 != num3 && count >= 1)) && num3 >= num2) {
+                    result.add(List.of(num1, num2, num3));
+                }
+            }
+
+            counter.remove(num1);
+        }
+
+        return result;
+    }
+}

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

@@ -0,0 +1,21 @@
+// Time Complexity: O(n), where n is the length of the prices array
+// Space Complexity: O(1)
+
+function maxProfit(prices: number[]): number {
+  // input: an array prices, prices[i] = the stock price of ith day
+  // output: the maximum profit || 0
+
+  // prices = [7, 1, 5, 3, 6, 4]
+  // buy = 1, sell = 6, profit = 6 -1 = 5
+
+  let minBuy = prices[0];
+  let maxProfit = 0;
+
+  for (let i = 1; i < prices.length; i++) {
+    minBuy = Math.min(prices[i], minBuy);
+    maxProfit = Math.max(prices[i] - minBuy, maxProfit);
+  }
+
+  return maxProfit;
+}
+

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

@@ -0,0 +1,17 @@
+// time: O(n) space: O(n)
+class Solution {
+    func maxProfit(_ prices: [Int]) -> Int {
+        guard !prices.isEmpty else { return 0 }
+        var result = [Int]()
+        var current = prices[0]
+
+        for price in prices {
+            if current > price {
+                current = price
+                continue
+            }
+            result.append(price - current)
+        }
+        return result.max() ?? 0
+    }
+}

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

@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function (prices) {
+  // 가장 작은 수
+  let minNum = prices[0];
+  // 차이 값
+  let maxProfit = 0;
+  for (let i = 1; i < prices.length; i++) {
+    minNum = Math.min(minNum, prices[i - 1]); // 이전꺼 중 가장 작은 수
+    maxProfit = Math.max(maxProfit, prices[i] - minNum);
+  }
+  return maxProfit;
+};

best-time-to-buy-and-sell-stock/YoungSeok-Choi.java

@@ -0,0 +1,24 @@
+// NOTE: tc --> O(n)
+class Solution {
+    public int maxProfit(int[] prices) {
+
+        int curMax = 0;
+        int gMax = 0;
+
+        if(prices.length == 0) return 0;
+        
+        int sell = prices[0];
+        for(int i = 1; i < prices.length; i++) {
+            curMax = Math.max(0, prices[i] - sell);
+
+            // NOTE: 새롭게 시작하는게 더 좋은경우
+            if(curMax == 0) {
+                sell = prices[i];
+            }
+
+            gMax = Math.max(curMax, gMax); 
+        }
+
+        return gMax;        
+    }
+}

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

@@ -0,0 +1,25 @@
+from typing import List
+class Solution:
+    """
+        - Time Complexity: O(n), n = len(prices)
+        - Space Complexity: O(1)
+    """
+    def maxProfit(self, prices: List[int]) -> int:
+        min_price = float("inf")
+        max_profit = 0
+
+        for price in prices:
+            min_price = min(min_price, price)
+            max_profit = max(max_profit, price - min_price)
+
+        return max_profit
+
+tc = [
+        ([7,1,5,3,6,4], 5),
+        ([7,6,4,3,1], 0)
+]
+
+for i, (prices, e) in enumerate(tc, 1):
+    sol = Solution()
+    r = sol.maxProfit(prices)
+    print(f"TC {i} is Passed!" if r == e else f"TC {i} is Failed! - Expected: {e}, Result: {r}")

best-time-to-buy-and-sell-stock/haung921209.md

@@ -0,0 +1,53 @@
+# 연관 링크
+- [문제 풀이 스케줄](https://github.com/orgs/DaleStudy/projects/6/views/5)
+- [답안 코드 제출법](https://github.com/DaleStudy/leetcode-study/wiki/%EB%8B%B5%EC%95%88-%EC%A0%9C%EC%B6%9C-%EA%B0%80%EC%9D%B4%EB%93%9C)
+
+# Problem
+- 문제 링크 : https://leetcode.com/problems/best-time-to-buy-and-sell-stock/
+- 문제 이름 : Best Time to Buy and Sell Stock
+- 문제 번호 : 121
+- 난이도 : easy
+- 카테고리 :
+
+# 문제 설명
+
+
+# 아이디어
+- 어떤 방법으로 접근했는지 서술
+- 포스 vs 최적화 아이디어 차이 등
+- 잡도에 대한 고려
+
+# ✅ 코드 (Solution)
+
+```cpp
+class Solution {
+public:
+    int maxProfit(vector<int>& prices) {
+        int localMax = prices[prices.size()-1];
+        int res = 0;
+        for(int i=prices.size()-2;i>=0;i--){
+            localMax = max(localMax, prices[i]);
+            res = max(res, localMax-prices[i]);
+        }
+
+        return res;
+    }
+};
+```
+
+# 🔍 코드 설명
+
+- local max를 설정
+
+# 최적화 포인트 (Optimality Discussion)
+•	최적화한 이유와 원리
+•	더 줄일 수 있는 여지는 있는가?
+•	기존 방법 대비 얼마나 효율적이었는지
+
+# 🧪 테스트 & 엣지 케이스
+
+# 📚 관련 지식 복습
+
+# 🔁 회고
+
+

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

@@ -0,0 +1,26 @@
+# TC: O(N), SC: O(1)
+
+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)
+        return max_profit
+
+# TS 풀이
+# 배열 요소(숫자값)을 직접 순회하려면 for ... of 사용 혹은 forEach
+# for ... in -> 인덱스를 가져옴
+
+# function maxProfit(prices: number[]): number {
+#     let max_profit: number = 0;
+#     let min_price: number = prices[0];
+
+#     for (let price of prices) {
+#         max_profit = Math.max(max_profit, price - min_price);
+#         min_price = Math.min(min_price, price);
+#     }
+#     return max_profit;
+# };

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

@@ -0,0 +1,20 @@
+/* 
+    time complexity : O(n)
+    space complexity : O(1)
+*/
+function maxProfit(prices: number[]): number {
+    let left = 0
+    let right = 0
+    let maxProfit = 0
+
+    while (right < prices.length) {
+        const curProfit = prices[right] - prices[left]
+        if (prices[left] < prices[right]) {
+            maxProfit = Math.max(curProfit, maxProfit)
+        } else {
+            left = right
+        }
+        right += 1
+    }
+    return maxProfit
+};

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

@@ -0,0 +1,14 @@
+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;
+};