Merge branch 'DaleStudy:main' into main

Author: dev-jonghoonpark

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

@@ -0,0 +1,34 @@
+'''
+Brainstorm
+- Brute force: double for-loop O(N^2)
+- Efficient: single pass O(N)
+
+Plan
+1. Initialize the variables
+2. Iterate through each price
+    2-1. Update the min price
+    2-2. Calculate and update max profit
+3. Return the max profit
+'''
+
+
+def maxProfit(prices):
+    min_price = float('inf')
+    max_profit = 0
+    for price in prices:
+        if price < min_price:
+            min_price = price
+        elif price - min_price > max_profit:
+            max_profit = price - min_price
+    return max_profit
+
+#TC: O(N), SC: O(1)
+
+# Normal Case
+print(maxProfit([7, 1, 5, 3, 6, 4]) == 5)  
+print(maxProfit([7, 6, 4, 3, 1]) == 0)  
+
+# Edge Case
+print(maxProfit([]) == 0)  
+print(maxProfit([1]) == 0)  
+

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

@@ -0,0 +1,40 @@
+"""
+Solution
+
+Algorithm:
+    1. Iterate through the list in reverse.
+    2. Keep track of the maximum value seen so far.
+    3. Calculate the profit by subtracting the current value from the maximum value.
+    4. Update the profit if it is greater than the current profit.
+
+Time complexity: O(n)
+Space complexity: O(1)
+"""
+
+
+from typing import List
+
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        profit = 0
+        prev_max = 0
+
+        for i in reversed(range(len(prices) - 1)):
+            prev_max = max(prev_max, prices[i + 1])
+            profit = max(profit, prev_max - prices[i])
+
+        return profit
+
+
+def main():
+    test_cases = [[[7, 1, 5, 3, 6, 4], 5], [[7, 6, 4, 3, 1], 0]]
+    s = Solution()
+
+    for test_case in test_cases:
+        prices_input, expected = test_case
+        assert s.maxProfit(prices_input) == expected
+
+
+if __name__ == "__main__":
+    main()

best-time-to-buy-and-sell-stock/invidam.go

@@ -0,0 +1,10 @@
+func maxProfit(prices []int) int {
+	purchasePrice := prices[0]
+	maxBenefit := 0
+
+	for _, price := range prices {
+		purchasePrice = min(purchasePrice, price)
+		maxBenefit = max(maxBenefit, price-purchasePrice)
+	}
+	return maxBenefit
+}

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

@@ -0,0 +1,18 @@
+function maxProfit(prices: number[]): number {
+  let minPrice = Number.MAX_SAFE_INTEGER;
+  let maxProfit = 0;
+
+  for (let i = 0; i < prices.length; i++) {
+    if (prices[i] < minPrice) {
+      minPrice = prices[i];
+    }
+
+    const potentialProfit = prices[i] - minPrice;
+
+    if (maxProfit < potentialProfit) {
+      maxProfit = potentialProfit;
+    }
+  }
+
+  return maxProfit;
+}

contains-duplicate/JoyJaewon.py

@@ -0,0 +1,31 @@
+'''
+Brainstrom
+- brute force: double for-loop (O^2)
+- efficient approach: use set O(N)
+
+Plan
+1. Initialize the set
+2. Iterate over the array
+    2-1. For each element, check if it's in the set. If it is, return True
+    2-2. If not, add the num to the set
+3. Return False since no duplicates are found
+'''
+
+def containsDuplicate(nums):
+    num_set=set()
+    for num in nums:
+        if num in num_set:
+            return True
+        num_set.add(num)
+    return False
+
+#TC: O(N), SC: O(N)
+
+#Normal case
+print(containsDuplicate([1, 2, 3, 1]) == True)
+print(containsDuplicate([1, 2, 3, 4]) == False)
+
+#Edge case
+print(containsDuplicate([1]) == False)
+print(containsDuplicate([]) == False) 
+

contains-duplicate/bhyun-kim.py

@@ -0,0 +1,38 @@
+"""
+Solution
+
+Algorithm:
+    1. Create a set from the list.
+    2. If the length of the set is not equal to the length of the list, return True.
+    3. Otherwise, return False.
+
+Time complexity: O(n)
+Space complexity: O(n)
+"""
+
+
+from typing import List
+
+
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        return len(set(nums)) != len(nums)
+
+
+def main():
+    test_cases = [
+        [
+            [1, 2, 3, 1],
+            True,
+        ][[1, 2, 3, 4], False],
+        [[1, 1, 1, 3, 3, 4, 3, 2, 4, 2], True],
+    ]
+    s = Solution()
+
+    for test_case in test_cases:
+        nums_input, expected = test_case
+        assert s.containsDuplicate(nums_input) == expected
+
+
+if __name__ == "__main__":
+    main()

contains-duplicate/invidam.go

@@ -0,0 +1,9 @@
+func containsDuplicate(nums []int) bool {
+	appeared := make(map[int]bool)
+
+	for _, num := range nums {
+		appeared[num] = true
+	}
+
+	return len(appeared) != len(nums)
+}

contains-duplicate/sounmind.ts

@@ -0,0 +1,3 @@
+function containsDuplicate(nums: number[]): boolean {
+  return nums.length !== new Set(nums).size;
+}

invert-binary-tree/README.md

@@ -0,0 +1,2 @@
+- 문제: https://leetcode.com/problems/invert-binary-tree/
+- 풀이: https://www.algodale.com/problems/invert-binary-tree/

linked-list-cycle/README.md

@@ -0,0 +1,2 @@
+- 문제: https://leetcode.com/problems/linked-list-cycle/
+- 풀이: https://www.algodale.com/problems/linked-list-cycle/