Merge branch 'DaleStudy:main' into main

Author: eunhwa99

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

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

@@ -0,0 +1,21 @@
+/**
+ * https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/
+ * Runtime: 6ms, Memory: 62.30MB
+ *
+ * Time Complexity: O(N)
+ * Space Complexity: O(1)
+ */
+
+function maxProfit(prices: number[]): number {
+  let buyingPrice = prices[0];
+  let profit = 0;
+
+  for (const price of prices) {
+    buyingPrice = Math.min(price, buyingPrice);
+    profit = Math.max(profit, price - buyingPrice);
+  }
+
+  return profit;
+}
+
+maxProfit([7, 1, 5, 3, 6, 4]);

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

@@ -0,0 +1,24 @@
+class Solution {
+	public int maxProfit(int[] prices) {
+		int result = 0;
+		int maxProfit = 0;
+		int buyStock = prices[0];
+
+		// 한번 돌면서 나보다 작은 것이 나올 때까지 이익을 본다
+
+
+		for (int price: prices) {
+			// 나보다 작은 게 나오면 MAX 이익을 갱신하고 거기부서 다시 시작한다.
+			if (price < buyStock) {
+				result = Math.max(result, maxProfit);
+				maxProfit = 0;
+				buyStock = price;
+			} else {
+				maxProfit = Math.max(price - buyStock, maxProfit);
+			}
+		}
+
+		return Math.max(result, maxProfit);
+	}
+}
+

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

@@ -0,0 +1,15 @@
+# Big-O 예측
+# Time : O(n)
+# Space : O(1)
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        min_price = prices[0]
+        profit = 0
+
+        for price in prices[1:]:
+            if min_price > price:
+                min_price = price
+            
+            profit = max(profit, price - min_price)
+        return profit
+

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

@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function(prices) {
+  let answer = 0
+  let leftMin = prices[0]
+
+  for(let i = 1; i < prices.length; ++i) {
+      answer = Math.max(answer, prices[i] - leftMin);
+      leftMin = Math.min(prices[i], leftMin);
+  }
+
+  return answer;
+};
+

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

@@ -0,0 +1,40 @@
+// 투포인터를 쓸 필요 없음. 그냥 최소값을 찾아 빼주면 O(N)의 시간 복잡도를 얻을 수 있다.
+// 투포인터와 큰 차이가 없는 이유는 투포인터도 O(N)이기 때문. 아주 약간의 공간복잡도 차이만 있을 듯
+// 결과는 큰 차이 없으나 알고리즘 자체가 더 쉽다.
+class Solution {
+    public int maxProfit(int[] prices) {
+        int minPrice = Integer.MAX_VALUE;
+        int maxProfit = 0;
+
+        for (int price : prices) {
+            if (price < minPrice) {
+                minPrice = price;
+            } else {
+                maxProfit = Math.max(maxProfit, price - minPrice);
+            }
+        }
+
+        return maxProfit;
+    }
+}
+
+// 처음 생각한 투포인터 방식
+class Solution {
+    public int maxProfit(int[] prices) {
+        int left = 0;
+        int right = 1; 
+        int maxProfit = 0;
+
+        while (right < prices.length) {
+            if (prices[left] < prices[right]) {
+                int profit = prices[right] - prices[left];
+                maxProfit = Math.max(maxProfit, profit);
+            } else {
+                left = right;
+            }
+            right++;
+        }
+
+        return maxProfit;
+    }
+}

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

@@ -0,0 +1,9 @@
+class Solution:
+    # O(n), n = len(prices)
+    def maxProfit(self, prices: List[int]) -> int:
+        min_price = float('inf')
+        profit = 0
+        for price in prices:
+            min_price = min(min_price, price)
+            profit = max(profit, price - min_price)
+        return profit

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

@@ -0,0 +1,13 @@
+# O(N) times, O(1) spaces
+# price[i] 가격으로 팔아서 가장 수익을 많이 내려면, i-1번째까지 중 가장 값이 싼 날짜에서 주식을 사면 된다
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        max_profit = 0
+        min_price = prices[0]
+
+        for price in prices:
+            profit = price - min_price
+            max_profit = max(max_profit, profit)
+            min_price = min(min_price, price)
+        
+        return max_profit