Merge remote-tracking branch 'upstream/main'

Author: mykoo

3sum/HC-kang.ts

@@ -0,0 +1,36 @@
+/**
+ * https://leetcode.com/problems/3sum/description
+ * T.C: O(n^2)
+ * S.C: O(1)
+ */
+function threeSum(nums: number[]): number[][] {
+  nums.sort((a, b) => a - b);
+
+  const result: number[][] = [];
+
+  for (let i = 0; i < nums.length - 2; i++) { // O(n)
+    if (i > 0 && nums[i] == nums[i - 1]) continue;
+
+    let left = i + 1;
+    let right = nums.length - 1;
+
+    while (left < right) { // O(n)
+      const sum = nums[i] + nums[left] + nums[right];
+      if (sum == 0) {
+        result.push([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--;
+      } else if (sum < 0) {
+        left++;
+      } else {
+        right--;
+      }
+    }
+  }
+
+  return result;
+}

3sum/flynn.py

@@ -0,0 +1,48 @@
+'''
+풀이
+- 중복되는 triplet을 피하기 위해 배열 nums를 정렬합니다
+- nums를 순회하며 이중 반복문을 수행하여 res 배열을 만듭니다
+- 중복되는 triplet을 피하기 위해 appended set을 이용합니다
+
+Big O
+- N: 배열 nums의 크기
+
+- Time complexity: O(N^2)
+  - nums를 정렬하는데 걸리는 시간은 NlogN 형태로 증가합니다
+  - 이중 반복문을 실행하는데 걸리는 시간은 N^2 형태로 증가합니다
+  - O(NlogN + N^2)에서 증가율이 가장 큰 항은 N^2이므로 시간복잡도는 O(N^2)이라고 볼 수 있습니다
+
+- Space complexity: O(N)
+  - nums를 정렬한 배열을 복사하여 sorted_nums에 저장하였고 이에 필요한 공간은 N의 형태로 증가합니다
+  - 첫번째 반복문 안의 store은 최대 N만큼 커질 수 있습니다
+  - appended 집합은 nums의 모든 원소가 고유하더라도 N보다 커질 수 없습니다
+'''
+
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        n = len(nums)
+
+        sorted_nums = sorted(nums)
+
+        res = []
+
+        for i in range(n - 2):
+            first = sorted_nums[i]
+            
+            if i > 0 and first == sorted_nums[i - 1]:
+                continue
+            
+            store = {}
+            store[-first - sorted_nums[i + 1]] = sorted_nums[i + 1]
+
+            appended = set()
+
+            for j in range(i + 2, n):
+                second = sorted_nums[j]
+
+                if second in store and second not in appended:
+                    res.append([first, store[second], second])
+                    appended.add(second)
+                store[-first - second] = second
+        
+        return res

3sum/hwanmini.js

@@ -0,0 +1,39 @@
+// 시간복잡도 O(n2)
+// 공간복잡도 O(k) (k는 결과 개수)
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function(nums) {
+    nums.sort((a, b) => a - b);
+
+    let result = []
+
+    for (let i = 0 ; i <= nums.length - 2; i++) {
+        if (i > 0 && nums[i] === nums[i-1]) continue
+
+        const curNum = nums[i]
+        let leftIdx = i+1;
+        let rightIdx = nums.length - 1;
+
+        while (leftIdx < rightIdx) {
+            const leftNum = nums[leftIdx]
+            const rightNum = nums[rightIdx]
+            const threeSum = curNum + leftNum + rightNum
+            if (threeSum === 0) {
+                result.push([curNum, leftNum, rightNum])
+                while (leftIdx < rightIdx && nums[leftIdx] === nums[leftIdx+1]) leftIdx++
+                while (leftIdx < rightIdx && nums[rightIdx] === nums[rightIdx-1]) rightIdx--
+                leftIdx++
+                rightIdx--
+            } else if (threeSum < 0) {
+                leftIdx = leftIdx + 1
+            } else if (threeSum > 0) {
+                rightIdx = rightIdx - 1
+            }
+        }
+
+    }
+
+    return result
+};

3sum/kayden.py

@@ -0,0 +1,62 @@
+class Solution:
+
+    # 해시맵
+    # 시간복잡도: O(N^2)
+    # 공간복잡도: O(N)
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        n = len(nums)
+        nums.sort()
+
+        check = {}
+        for idx, num in enumerate(nums):
+            check[num] = idx
+
+        answer = set()
+        for i in range(n-2):
+            if nums[i] > 0:
+                break
+            if i > 0 and nums[i] == nums[i-1]:
+                continue
+            for j in range(i + 1, n):
+                target = -(nums[i] + nums[j])
+                if not check.get(target):
+                    continue
+                if j >= check[target]:
+                    continue
+
+                answer.add((nums[i], nums[j], target))
+
+        return list(answer)
+
+    # 투포인터
+    # 시간복잡도: O(N^2)
+    # 공간복잡도: O(N)
+    def threeSum2(self, nums: List[int]) -> List[List[int]]:
+        n = len(nums)
+        nums.sort()
+
+        answer = set()
+        for i in range(n-2):
+            if nums[i] > 0:
+                break
+            if i > 0 and nums[i] == nums[i-1]:
+                continue
+            l, r = i+1, n-1
+            while l<r:
+                if nums[l] + nums[r] == -nums[i]:
+                    answer.add((nums[i], nums[l], nums[r]))
+                    l += 1
+                    r -= 1
+                    while nums[l] == nums[l - 1] and l < r:
+                        l += 1
+
+                    while nums[r] == nums[r + 1] and l < r:
+                        r -= 1
+
+                if nums[l] + nums[r] < -nums[i]:
+                    l += 1
+
+                if nums[l] + nums[r] > -nums[i]:
+                    r -= 1
+
+        return list(answer)

3sum/taekwon-dev.java

@@ -0,0 +1,42 @@
+/**
+ *  시간 복잡도: O(n^2)
+ *  공간 복잡도: O(n)
+ */
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        int left, right, sum;
+        List<List<Integer>> results = new ArrayList<>();
+        Arrays.sort(nums);
+
+        for (int i = 0; i < nums.length - 2; i++) {
+            if (i > 0 && nums[i] == nums[i - 1]) {
+                continue;
+            }
+
+            left = i + 1;
+            right = nums.length - 1;
+
+            while (left < right) {
+                sum = nums[i] + nums[left] + nums[right];
+
+                if (sum < 0) {
+                    left++;
+                } else if (sum > 0) {
+                    right--;
+                } else {
+                    results.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 results;
+    }
+}

3sum/tolluset.ts

@@ -0,0 +1,56 @@
+/*
+ * TC: O(n^2)
+ * SC: O(n)
+ * */
+function threeSum(nums: number[]): number[][] {
+  const n = nums.length;
+  const res: number[][] = [];
+
+  nums.sort((a, b) => a - b);
+
+  for (let i = 0; i < n - 2; i++) {
+    if (i > 0 && nums[i] === nums[i - 1]) {
+      continue;
+    }
+
+    let left = i + 1,
+      right = n - 1;
+
+    while (left < right) {
+      const sum = nums[i] + nums[left] + nums[right];
+
+      if (sum === 0) {
+        res.push([nums[i], nums[left], nums[right]]);
+
+        while (nums[left] === nums[left + 1]) {
+          left++;
+        }
+
+        while (nums[right] === nums[right - 1]) {
+          right++;
+        }
+
+        left++;
+        right--;
+
+        continue;
+      }
+
+      if (sum < 0) {
+        left++;
+
+        continue;
+      }
+
+      right--;
+    }
+  }
+
+  return res;
+}
+
+const tc1 = threeSum([-1, 0, 1, 2, -1, -4]); // [[-1,-1,2],[-1,0,1]]
+console.info("🚀 : tolluset.ts:39: tc1=", tc1);
+
+const tc2 = threeSum([0, 0, 0]); // [[0,0,0]]
+console.info("🚀 : tolluset.ts:42: tc2=", tc2);

best-time-to-buy-and-sell-stock/HC-kang.ts

@@ -0,0 +1,19 @@
+// https://leetcode.com/problems/best-time-to-buy-and-sell-stock/
+// T.C: O(N)
+// S.C: O(1)
+function maxProfit(prices: number[]): number {
+  let min = prices[0];
+  let max = prices[0];
+  let candidate = prices[0];
+
+  for (let i = 1; i < prices.length; i++) {
+    if (prices[i] < candidate) {
+      candidate = prices[i];
+    } else if (prices[i] - candidate > max - min) {
+      min = candidate;
+      max = prices[i];
+    }
+  }
+
+  return max - min;
+}

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

@@ -0,0 +1,40 @@
+'''
+풀이
+- 주어진 배열 prices를 한 번 탐색합니다.
+
+- prices[i]가 이전에 저장한 buy_price보다 낮을 경우,
+  maximum profit이 증가할 가능성이 있습니다.
+  따라서 buy_price와 sell_price를 prices[i]로 바꿔줍니다.
+  
+- prices[i]가 이전에 저장한 sell_price보다 높은 경우,
+  현재 buy_price로 지금까지 기록한 profit보다 더 높은 이익을 내게 됩니다.
+  따라서 sell_price를 prices[i]로 바꿔주고 결과값을 갱신합니다.
+
+Big O
+- N: 배열 prices의 크기
+
+- Time complexity: O(N)
+  - 배열의 크기 N이 증가함에 따라 실행 시간도 선형적으로 증가합니다.
+
+- Space complexity: O(1)
+  - 배열의 크기 N이 증가하여도 사용하는 메모리 공간은 일정합니다.
+'''
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:        
+        res = 0
+
+        buy_price = prices[0]
+        sell_price = prices[0]
+
+        for i in range(1, len(prices)):
+            curr_price = prices[i]
+
+            if buy_price > curr_price:
+                buy_price = curr_price
+                sell_price = curr_price
+            elif sell_price < curr_price:
+                sell_price = curr_price
+                res = max(res, sell_price - buy_price)
+
+        return res

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

@@ -0,0 +1,23 @@
+// 시간복잡도: O(n)
+// 공간복잡도: O(1)
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function(prices) {
+    if (!prices || !prices.length) return 0
+
+    let maxBenefit = 0;
+    let buyPrice = Infinity;
+
+    for (let i = 0 ; i < prices.length ; i++) {
+        buyPrice = Math.min(buyPrice, prices[i]);
+        maxBenefit = Math.max(maxBenefit, prices[i] - buyPrice)
+    }
+
+
+    return maxBenefit
+};
+
+console.log(maxProfit([7,1,5,3,6,4]))
+console.log(maxProfit([7,6,4,3,1]))

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

@@ -0,0 +1,15 @@
+# 시간복잡도: O(N)
+# 공간복잡도: O(1)
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+
+        answer = 0
+        cur = float(inf)
+        for price in prices:
+            if cur < price:
+                answer = max(answer, price - cur)
+
+            if price < cur:
+                cur = price
+
+        return answer