Merge branch 'DaleStudy:main' into main

3sum/yoonthecoder.js

@@ -0,0 +1,27 @@
+var threeSum = function (nums) {
+  nums.sort((a, b) => a - b);
+  const results = [];
+  for (let i = 0; i < nums.length - 2; i++) {
+    if (i > 0 && nums[i] === nums[i - 1]) continue;
+    let left = i + 1;
+    let right = nums.length - 1;
+    while (left < right) {
+      const currSum = nums[i] + nums[left] + nums[right];
+
+      if (currSum == 0) {
+        results.push([nums[i], nums[left], nums[right]]);
+        left++;
+        right--;
+        // to avoid duplicates
+        while (left < right && nums[left] === nums[left - 1]) left++;
+        while (left < right && nums[right] === nums[right + 1]) right--;
+      } else if (currSum < 0) {
+        left++;
+      } else right--;
+    }
+  }
+  return results;
+};
+
+// Time complexity: O(n^2);
+// Space complexity: O(n)

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/EcoFriendlyAppleSu.kt

@@ -0,0 +1,43 @@
+package leetcode_study
+
+/*
+* 두 거래일 사이 최고의 수익을 구하는 문제
+* 시간 복잡도: O(n^2)
+* -> 모든 경우의 수를 순회하며 거래일 사이 최고 가격을 구하는 로직: O(n^2)
+* 공간 복잡도: O(1)
+* 아래 로직은 시간 초과 발생 O(n^2)의 복잡도를 줄여야함.
+* */
+fun maxProfit(prices: IntArray): Int {
+    var result = Int.MIN_VALUE
+
+    for (i in prices.indices) {
+        for (j in i + 1 until prices.size) {
+            if (prices[i] < prices[j]) {
+                if (result < prices[j] - prices[i]) {
+                    result = prices[j] - prices[i]
+                }
+            }
+        }
+    }
+    if (result == Int.MIN_VALUE) return 0
+    return result
+}
+
+/*
+* 가장 작은 값을 저장하는 변수와 가장 큰 수익을 갖는 변수를 두고 문제 해결
+* 시간 복잡도: O(n)
+* 공간 복잡도: O(1)
+* */
+fun maxProfit2(prices: IntArray): Int {
+    var minValue = Int.MAX_VALUE
+    var maxValue = 0
+
+    for (price in prices) {
+        if (price < minValue) {
+            minValue = price
+        } else if (price - minValue > maxValue) {
+            maxValue = price - minValue
+        }
+    }
+    return maxValue
+}

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/HerrineKim.js

@@ -0,0 +1,24 @@
+// 시간복잡도: O(n)
+// 공간복잡도: O(1)
+
+// 최소값을 계속 갱신하면서 최대 이익을 계산
+
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+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/HodaeSsi.py

@@ -0,0 +1,13 @@
+# 시간 복잡도 : O(n)
+# 공간 복잡도 : O(1)
+class Solution:
+	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
+

best-time-to-buy-and-sell-stock/Jay-Mo-99.py

@@ -0,0 +1,27 @@
+        #해석
+        #prices list를 순회하면서 최솟값 min_val을 업데이트 한다
+        #현재 prices[n]과 min_val의 차를 업데이트 해준다. 
+
+
+        #Big O
+        #N: prices 의 크기
+
+        #Time Complexity: O(N)
+        #- for loop : prices의 원소 갯수만큼 순회하므로 O(N)
+
+
+        #Space Complexity: O(1)
+        #- min_val, answer : 변수는 상수이므로 O(1)
+class Solution(object):
+    def maxProfit(self, prices):
+
+        #Initialize variables
+        min_val = prices[0] 
+        answer = 0
+
+        for n in range(len(prices)):
+            min_val= min(min_val,prices[n]) #Update min value of the prices list
+            answer = max(prices[n]-min_val,answer) #Update max value of prices[n] - min value
+
+        return answer
+

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

@@ -0,0 +1,41 @@
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+
+// TC : O(n)
+// SC : O(1)
+
+var maxProfit = function (prices) {
+  if (prices.length === 1) {
+    return 0;
+  }
+
+  // Two variables (profitMax and priceMin) are used to store the maximum profit and minimum price seen, which require O(1) space.
+  let profitMax = 0;
+  let priceMin = prices[0];
+
+  for (const price of prices) {
+    const profit = price - priceMin;
+    profitMax = Math.max(profit, profitMax);
+    priceMin = Math.min(price, priceMin);
+  }
+
+  return profitMax;
+};
+
+// Why Constants Are Ignored in Big-O
+// In Big-O notation, O(2) is simplified to O(1) because constants are irrelevant in asymptotic analysis.
+// Big-O focuses on how resource usage scales with input size, not fixed values.
+
+// Using 2 variables: O(1)
+// Using 10 variables: O(1)
+// Using 100 variables: O(1)
+
+// What Space Complexity Looks Like for Larger Growth
+// O(n): Memory grows linearly with the input size (e.g., storing an array of n elements).
+// O(n^2): Memory grows quadratically (e.g., a 2D matrix with n*n elements).
+// 𝑂(log 𝑛): Memory grows logarithmically (e.g., recursive calls in binary search).
+// O(1): Fixed memory usage, regardless of input size (e.g., using a fixed number of variables).
+
+

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

@@ -0,0 +1,30 @@
+"""
+Constraints:
+1. 1 <= prices.length <= 10^5
+2. 0 <= prices[i] <= 10^4
+
+Time Complexity: O(n)
+
+Space Complexity: O(1)
+
+풀이 방법:
+- 배열을 한 번 순회하면서:
+   1. 현재까지의 최소 가격(min_price)을 계속 갱신
+   2. 현재 가격에서 최소 가격을 뺀 값(현재 가능한 이익)과 기존 최대 이익을 비교하여 더 큰 값을 저장
+- 이 방식으로 각 시점에서 가능한 최대 이익을 계산함
+
+To Do:
+- 다른 접근 방법 찾아보기 (Two Pointers, Dynamic Programming)
+"""
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        min_price = prices[0]
+        max_profit = 0
+
+        for i in range(1, len(prices)):
+            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/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/Yjason-K.ts

@@ -0,0 +1,28 @@
+/**
+ * 최대 이익을 계산하는 함수 
+ * @param {number[]} prices 
+ * @returns {number}
+ * 
+ * 시간 복잡도 : O(n) (n: 주식 가격 배열의 길이)
+ * 공간 복잡도 : 0(1) (추가 자료구조 X)
+ */
+function maxProfit(prices: number[]): number {
+    let minPrice = 100001; // 지금까지의 최소 가격
+    let maxProfit = 0; // 최대 이익
+
+    for (let price of prices) {
+        // 최소 가격 갱신
+        if (price < minPrice) {
+            minPrice = price;
+        }
+
+        // 현재 가격에서 최소 가격을 뺀 이익이 최대 이익보다 크다면 갱신
+        const potentialProfit = price - minPrice;
+        if (potentialProfit > maxProfit) {
+            maxProfit = potentialProfit;
+        }
+    }
+
+    return maxProfit;
+}
+

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

@@ -0,0 +1,19 @@
+# 시간복잡도 O(n)
+# 공간복잡도 O(1)
+class Solution:
+	def maxProfit(self, prices: list[int]) -> int:
+		min_p = prices[0] # 최소 가격 설정  : 배열의 첫 번째 가격
+		cur = 0
+		max_p = 0
+		for n in prices:
+			if n < min_p: # 현재 가격이 최소 가격보다 작다면 최소가격 갱신
+				min_p = n
+			cur = n - min_p # 현재 이익 계산
+			if max_p < cur: # 현재 이익과 최대로 얻을 수 있는 이익 비교
+				max_p = cur # 최대 이익 갱신신
+
+		return max_p
+
+
+
+

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

@@ -0,0 +1,18 @@
+/**
+ * 시간 복잡도: prices.length만큼 순회하므로 O(n)
+ * 공간 복잡도: 상수 크기의 변수만 사용하므로 O(1)
+ */
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function (prices) {
+  let maxProfit = 0;
+  let min = prices[0];
+
+  for (let i = 0; i < prices.length; i++) {
+      maxProfit = Math.max(maxProfit, prices[i] - min);
+      min = Math.min(min, prices[i]);
+  }
+  return maxProfit;
+};