Merge remote-tracking branch 'origin/main'

Author: smosco

3sum/chjung99.java

@@ -0,0 +1,48 @@
+// two pointer
+// time: O(N^2)
+// space: O(N)
+
+class Solution {
+    Set<List<Integer>> set = new HashSet<>();
+    public List<List<Integer>> threeSum(int[] nums) {
+        Arrays.sort(nums);
+
+        for (int i = 0; i < nums.length; i++){
+            twoSum(nums, i);
+        }
+
+        return new ArrayList<>(set);
+    }
+    public void twoSum(int[] nums, int targetIdx){
+        int left = 0;
+        int right = nums.length - 1;
+
+        while (left < right) {
+            if (left == targetIdx){
+                left ++;
+                continue;
+            }
+            if (right == targetIdx){
+                right--;
+                continue;
+            }
+            if (nums[left] + nums[right] == -nums[targetIdx]) {
+                if (nums[left] > nums[targetIdx]){
+                    set.add(List.of(nums[targetIdx], nums[left], nums[right]));
+                }
+                else if (nums[targetIdx] > nums[right]){
+                    set.add(List.of(nums[left],nums[right],nums[targetIdx]));
+                } else{
+                    set.add(List.of(nums[left], nums[targetIdx], nums[right]));
+                }
+                left++;
+            } else if (nums[left] + nums[right] < -nums[targetIdx]){
+                left ++;
+            } else {
+                right --;
+            }
+        }
+    }
+}
+
+

3sum/ymir0804.java

@@ -0,0 +1,39 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        List<List<Integer>> answer = new ArrayList<>();
+        Arrays.sort(nums);
+        int sum = 0;
+
+        for (int i = 0; i < nums.length-2; i++) {
+            int left = i + 1;
+            int right = nums.length -1;
+            if(i > 0 && nums[i-1] == nums[i]) {
+                continue;
+            }
+            while (left < right ) {
+                sum = nums[i] + nums[left] + nums[right];
+                if(sum > 0) {
+                    right--;
+                } else if(sum < 0 ) {
+                    left++;
+                } else {
+                    answer.add(Arrays.asList(nums[i], nums[left], nums[right]));
+                    while (left < right && nums[left] == nums[left + 1]) {
+                        left++;
+                    }
+                    while (left < right && nums[right] == nums[right - 1]) {
+                        right--;
+                    }
+                    left++;
+                    right--;
+                }
+            }
+
+        }
+        return answer;
+    }
+}

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

@@ -0,0 +1,68 @@
+/**
+일단 가장 단순하게 생각했을 때,
+n^2 의 시간 복잡도를 가지면 모든 경우의 수를 확인가능하다.
+
+function maxProfit(prices: number[]): number {
+    let maximum = 0
+    for(let i=0; i<prices.length-1; i++) {
+        for(let j=i; j<prices.length; j++) {
+            if(prices[j] - prices[i] > maximum) maximum = prices[j] - prices[i]
+        }
+    }
+    return maximum
+};
+ */
+
+/** 
+하지만 시간 초과가 발생하니, 다른 방법을 써보자.
+이익을 구하기 위해서는 가장 낮은 지점과 가장 큰 지점에 대한 탐색이 필요하다.
+가장 낮은 지점은 큰 지점보다 앞에 위치해야 한다.
+
+만약 투 포인터로 양 끝에서 오면서 왼쪽은 가장 낮은 것, 오른쪽은 가장 높은 것을 확인해서
+두 포인터가 만날 때 차분을 구한다면?
+
+function maxProfit(prices: number[]): number {
+    let left = prices[0];
+    let right = prices[prices.length-1];
+    for (let i=0; i<prices.length; i++) {
+        if (i > (prices.length - 1 - i)) {
+            break
+        }
+
+        if (prices[i] < left) {
+            left = prices[i]
+        }
+
+        if (prices[prices.length - 1 - i] > right) {
+            right = prices[prices.length - 1 - i]
+        }
+    }
+
+    return left > right ? 0 : right - left
+}; 
+*/
+
+/**
+[3,2,6,5,0,3] 와 같은 경우에 일반화 되지 못한다.
+정답을 기준으로, 큰 값 이후에는 그보다 큰 값이 없어야 하고,
+작은 값 이전에는 그보다 작은 값이 없어야 한다.
+
+그렇다면 포인터를 이 기준에 맞게 급격히 옮겨볼까?
+... 
+힌트를 보고 왔다. 단순하게 최저값을 항상 갱신해주면 되는구나.
+ */
+function maxProfit(prices: number[]): number {
+  let min = 10000;
+  let max = 0;
+  for (let i = 0; i < prices.length; i++) {
+    if (prices[i] < min) {
+      min = prices[i];
+      continue;
+    }
+
+    if (prices[i] - min > max) {
+      max = prices[i] - min;
+    }
+  }
+  return max;
+}

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

@@ -0,0 +1,16 @@
+function maxProfit(prices: number[]): number {
+  let min = prices[0];
+  let max = 0;
+
+  for (let i = 0; i < prices.length; i++) {
+    min = Math.min(min, prices[i]);
+    max = Math.max(max, prices[i] - min);
+  }
+
+  return max;
+}
+
+const prices = [3, 3, 5, 0, 0, 3, 1, 4];
+maxProfit(prices);
+
+

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

@@ -0,0 +1,26 @@
+/**
+ * Runtime: 1ms
+ * Time Complexity: O(n)
+ *
+ * Memory: 94.08MB
+ * Space Complexity: O(1)
+ *
+ * Approach: 그리디 알고리즘
+ * - 주어진 prices 배열을 순회하며 최소 가격(min)을 갱신
+ */
+class Solution {
+    public int maxProfit(int[] prices) {
+        int maxProfit = 0;
+        int min = prices[0];
+
+        for (int i=1; i<prices.length; i++) {
+            if (min >= prices[i]) {
+                min = prices[i];
+            } else {
+                maxProfit = Math.max(maxProfit, prices[i]-min);
+            }
+        }
+
+        return maxProfit;
+    }
+}

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

@@ -0,0 +1,23 @@
+'''
+문제: 한번의 구매와 판매로 얻을 수 있는 최대 이익을 구하라.
+풀이: 주어진 가격 리스트를 순회하면서 최저가와 최고가를 갱신하며 최대 이익을 계산한다.
+    최저가는 현재 최저가격보다 낮은 가격이 나오면 갱신하고, 
+    최고가는 현재 최고가격보다 높은 가격이 나오면 갱신및 정답인지 비교한다.
+시간복잡도: O(n)
+공간복잡도: O(1)
+
+'''
+
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        ma, mi = prices[0], prices[0]
+        answ = 0
+        for i in range(1, len(prices)):
+            if mi > prices[i]:
+                mi, ma = prices[i], prices[i]
+            if ma < prices[i]:
+                ma = prices[i]
+                answ = max(answ, ma-mi)
+        return answ
+

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

@@ -0,0 +1,11 @@
+function maxProfit(prices: number[]): number {
+  const dp = new Array(prices.length).fill(0);
+  dp[0] = 0;
+  let maxProfit = 0;
+  for (let i = 1; i < prices.length; i++) {
+    dp[i] = Math.max(prices[i] - prices[i - 1], prices[i] - prices[i - 1] + dp[i - 1]);
+
+    maxProfit = Math.max(dp[i], maxProfit);
+  }
+  return maxProfit;
+}

best-time-to-buy-and-sell-stock/daiyongg-kim.py

@@ -0,0 +1,12 @@
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        min_price = prices[0]
+        max_profit = 0
+
+        for price in prices[1:]:
+            if price < min_price:
+                min_price = price
+            elif price - min_price > max_profit:
+                max_profit = price - min_price
+            
+        return max_profit

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

@@ -0,0 +1,32 @@
+"""
+Blind 75 - Best Time to Buy and Sell Stock
+https://leetcode.com/problems/best-time-to-buy-and-sell-stock/
+
+시간복잡도 : O(n)
+공간복잡도 : O(1)
+풀이 : 한 번의 순회로 해결
+
+prices = [7,1,5,3,6,4]
+
+price | min | max_profit
+    7   |  7  |    0
+    1   |  1  |    0
+    5   |  1  |    4
+    3   |  1  |    4
+    6   |  1  |    5
+    4   |  1  |    5
+
+"""
+from typing import List
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        max_profit = 0
+        min_price = prices[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/doh6077.py

@@ -0,0 +1,18 @@
+
+# 121. Best Time to Buy and Sell Stock
+# O(n) - Two Pointers 
+class Solution:
+    def maxProfit(self, prices: list[int]) -> int:
+        left = 0 
+        right = 1
+        profit = 0
+        max_profit = 0 
+
+        while right < len(prices):
+            if prices[right] > prices[left]:
+                profit = prices[right] - prices[left]
+                max_profit = max(profit, max_profit)
+            else:
+                left = right
+            right += 1
+        return max_profit