Merge branch 'DaleStudy:main' into main

dev-jonghoonpark · web-flow · commit 8365abe37d69 · 2024-05-01T14:57:45.000+09:00
diff --git a/best-time-to-buy-and-sell-stock/Bumsu-Yi.py b/best-time-to-buy-and-sell-stock/Bumsu-Yi.py
@@ -1,3 +1,16 @@
 """
 https://leetcode.com/problems/best-time-to-buy-and-sell-stock/
 """
+
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        max_profit = 0
+        min_price = prices[0]
+
+        for price in prices:
+            profit = price - min_price
+            min_price = min(min_price, price)
+            max_profit = max(profit, max_profit)
+
+        return max_profit
diff --git a/best-time-to-buy-and-sell-stock/Leo.py b/best-time-to-buy-and-sell-stock/Leo.py
@@ -0,0 +1,11 @@
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        minPrice = prices[0]
+        maxPro = 0
+
+        for i in range(1, len(prices)):
+            maxPro = max(maxPro, prices[i] - minPrice)
+            minPrice = min (minPrice, prices[i])
+
+        return maxPro
+        ## TC: O(n) SC: O(1)..?
diff --git a/best-time-to-buy-and-sell-stock/bky373.java b/best-time-to-buy-and-sell-stock/bky373.java
@@ -0,0 +1,22 @@
+/**
+ * https://leetcode.com/problems/best-time-to-buy-and-sell-stock/
+ * TC : O(N)
+ * SC : O(1)
+ */
+class Solution_0121 {
+    public int maxProfit(int[] prices) {
+        int hold = prices[0];
+        int profit = 0;
+
+        for (int i = 1; i < prices.length; i++) {
+            if (prices[i] < hold) {
+                hold = prices[i];
+            }
+
+            if (prices[i] - hold > profit) {
+                profit = prices[i] - hold;
+            }
+        }
+        return profit;
+    }
+}
diff --git a/best-time-to-buy-and-sell-stock/han.exs b/best-time-to-buy-and-sell-stock/han.exs
@@ -0,0 +1,10 @@
+defmodule Solution do
+  @spec max_profit(prices :: [integer]) :: integer
+  def max_profit([head | tail]) do
+        {_, answer} = Enum.reduce(tail, {head, 0}, fn x, {buy, profit} ->
+            {min(buy, x), max(profit, x - buy)}
+        end)
+
+        answer
+    end
+end
diff --git a/best-time-to-buy-and-sell-stock/saysimple.py b/best-time-to-buy-and-sell-stock/saysimple.py
@@ -0,0 +1,18 @@
+"""
+https://leetcode.com/problems/best-time-to-buy-and-sell-stock/
+"""
+# - time complexity : O(n)
+# - space complexity : O(n)
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        now = prices[0]
+        diff = [0] * len(prices)
+
+        for i, v in enumerate(prices[1:]):
+            if now > v:
+                now = v
+            else:
+                diff[i+1] = v - now
+
+        return max(diff)
diff --git a/best-time-to-buy-and-sell-stock/wclee2265.cpp b/best-time-to-buy-and-sell-stock/wclee2265.cpp
@@ -0,0 +1,17 @@
+// https://leetcode.com/problems/best-time-to-buy-and-sell-stock/
+// Time Complexity : O(n)
+// Space Complexity : O(1)
+
+class Solution {
+public:
+    int maxProfit(vector<int>& prices) {
+        int n = prices.size();
+        int minimum = prices[0];
+        int ans = 0;
+        for(int i=1; i<n; i++) {
+            ans = max(ans, prices[i] - minimum);
+            minimum = min(minimum, prices[i]);
+        }
+        return ans;
+    }
+};
diff --git a/contains-duplicate/Bumsu-Yi.py b/contains-duplicate/Bumsu-Yi.py
@@ -1,3 +1,15 @@
 """
 https://leetcode.com/problems/contains-duplicate/
 """
+
+
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        my_dict = {}
+
+        for num in nums:
+            if num in my_dict:
+                return True
+            my_dict[num] = 0
+
+        return False
diff --git a/contains-duplicate/Leo.py b/contains-duplicate/Leo.py
@@ -0,0 +1,13 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        return len(set(nums)) != len(nums)
+
+        # seen = set()
+
+        # for i in nums:   ## O(n)
+        #     if i in seen: ## O(1)
+        #         return True
+        #     else:
+        #         seen.add(i)
+
+        # return False
diff --git a/contains-duplicate/bky373.java b/contains-duplicate/bky373.java
@@ -0,0 +1,22 @@
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * https://leetcode.com/problems/contains-duplicate/
+ * TC : O(N)
+ * SC : O(N)
+ */
+class Solution_0217 {
+
+    public boolean containsDuplicate(int[] nums) {
+        Map<Integer, Integer> map = new HashMap();
+        for (int n : nums) {
+            if (map.containsKey(n)) {
+                return true;
+            } else {
+                map.put(n, 1);
+            }
+        }
+        return false;
+    }
+}
diff --git a/contains-duplicate/han.exs b/contains-duplicate/han.exs
@@ -0,0 +1,10 @@
+defmodule Solution do
+  @spec contains_duplicate(nums :: [integer]) :: boolean
+  def contains_duplicate(nums) do
+    if nums |> Enum.into(MapSet.new) |> Enum.to_list |> length == length(nums) do
+        false
+    else
+        true
+    end
+  end
+end
diff --git a/contains-duplicate/saysimple.py b/contains-duplicate/saysimple.py
@@ -0,0 +1,14 @@
+"""
+https://leetcode.com/problems/contains-duplicate/
+"""
+# - time complexity : O(n)
+# - space complexity : O(n)
+
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        visited = {}
+        for n in nums:
+            if n in visited:
+                return True
+            visited[n] = True
+        return False
diff --git a/contains-duplicate/wclee2265.cpp b/contains-duplicate/wclee2265.cpp
@@ -0,0 +1,15 @@
+// https://leetcode.com/problems/contains-duplicate/
+// Time Complexity : O(n)
+// Space Complexity : O(n)
+
+class Solution {
+public:
+    bool containsDuplicate(vector<int>& nums) {
+        unordered_map<int, bool> hm;
+        for(int x : nums) {
+            if(hm[x]) return true;
+            hm[x] = true;
+        }
+        return false;        
+    }
+};
diff --git a/two-sum/Bumsu-Yi.py b/two-sum/Bumsu-Yi.py
@@ -1,5 +1,15 @@
 """
 https://leetcode.com/problems/two-sum/
 """
-#
 
+
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        numMap = {}
+
+        for i in range(len(nums)):
+            complement = target - nums[i]
+            if complement in numMap:
+                return [numMap[complement], i]
+
+            numMap[nums[i]] = i
diff --git a/two-sum/Leo.py b/two-sum/Leo.py
@@ -0,0 +1,13 @@
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        seen = {}
+
+        for key, val in enumerate(nums):
+            diff = target - val
+
+            if diff in seen:
+                return [seen[diff], key]
+            else:
+                seen[val] = key
+
+    # TC: O(n), SC: O(n)
diff --git a/two-sum/bky373.java b/two-sum/bky373.java
@@ -0,0 +1,22 @@
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * https://leetcode.com/problems/two-sum/
+ * TC : O(N)
+ * SC : O(N)
+ */
+class Solution_0001 {
+
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> map = new HashMap<>();
+
+        for (int i = 0; i < nums.length; i++) {
+            if (map.containsKey(target - nums[i])) {
+                return new int[]{map.get(target - nums[i]), i};
+            }
+            map.put(nums[i], i);
+        }
+        return new int[]{};
+    }
+}
diff --git a/two-sum/han.exs b/two-sum/han.exs
@@ -0,0 +1,9 @@
+defmodule Solution do
+    def two_sum([head | tail], target, index\\0) do
+        second_index = Enum.find_index(tail, fn element -> 
+            head + element == target
+        end)
+
+        if second_index, do: [index, second_index + index + 1], else: two_sum(tail, target, index + 1)
+    end
+end
diff --git a/two-sum/saysimple.py b/two-sum/saysimple.py
@@ -0,0 +1,21 @@
+"""
+https://leetcode.com/problems/two-sum/
+"""
+# - time complexity : O(nlogn)
+# - space complexity : O(n)
+
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        s, e = 0, len(nums) - 1
+        arr = [nums[i]:=[n,i] for i, n in enumerate(nums)]
+
+        arr.sort(key=lambda x: x[0])
+
+        while s <= e:
+            now = arr[s][0] + arr[e][0]
+            if now == target:
+                return [arr[s][1], arr[e][1]]
+            if now < target:
+                s += 1
+            else:
+                e -= 1
diff --git a/two-sum/wclee2265.cpp b/two-sum/wclee2265.cpp
@@ -0,0 +1,27 @@
+// https://leetcode.com/problems/two-sum/
+// Time Complexity : O(nlogn)
+// Space Complexity : O(n)
+
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        int n = nums.size();
+        vector<pair<int, int> > numsIndices;
+
+        for(int i=0; i<n; i++){
+            numsIndices.push_back({nums[i], i});
+        }
+
+        sort(numsIndices.begin(), numsIndices.end());
+        int i, j = n-1;
+        for(i=0; i<n; i++) {
+            while(numsIndices[i].first + numsIndices[j].first > target) j--;
+            if(numsIndices[i].first + numsIndices[j].first == target) break;
+        }
+
+        vector<int> ans;
+        ans.push_back(numsIndices[i].second);
+        ans.push_back(numsIndices[j].second);
+        return ans;
+    }
+};
diff --git a/valid-anagram/Bumsu-Yi.py b/valid-anagram/Bumsu-Yi.py
@@ -1,3 +1,17 @@
 """
 https://leetcode.com/problems/valid-anagram/
 """
+
+
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        my_dict1 = {}
+        my_dict2 = {}
+
+        for char in s:
+            my_dict1[char] = my_dict1.get(char, 0) + 1
+
+        for char in t:
+            my_dict2[char] = my_dict2.get(char, 0) + 1
+
+        return my_dict1 == my_dict2
diff --git a/valid-anagram/Leo.py b/valid-anagram/Leo.py
@@ -0,0 +1,18 @@
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+
+        counter_dict = collections.defaultdict(int)
+
+        for i in s:
+            counter_dict[i] += 1
+
+        for i in t:
+            counter_dict[i] -= 1
+
+        for val in counter_dict.values():
+            if val != 0:
+                return False
+
+        return True
+        # TC:O(n), SC: O(len(s or t))
+        # return sorted(s) == sorted(t) ## O(nlogn)
diff --git a/valid-anagram/bky373.java b/valid-anagram/bky373.java
@@ -0,0 +1,26 @@
+/**
+ * https://leetcode.com/problems/valid-anagram/
+ * TC : O(N)
+ * SC : O(1)
+ */
+class Solution_242 {
+    public boolean isAnagram(String s, String t) {
+        if (s.length() != t.length()) {
+            return false;
+        }
+
+        int[] alpCnt = new int[26];
+
+        for (int i=0; i<s.length(); i++) {
+            alpCnt[s.charAt(i) - 'a']++;
+        }
+
+        for (int i = 0; i < s.length(); i++) {
+            if (alpCnt[t.charAt(i) - 'a'] < 1) {
+                return false;
+            }
+            alpCnt[t.charAt(i) - 'a']--;
+        }
+        return true;
+    }
+}
diff --git a/valid-anagram/han.exs b/valid-anagram/han.exs
@@ -0,0 +1,6 @@
+defmodule Solution do
+  @spec is_anagram(s :: String.t, t :: String.t) :: boolean
+  def is_anagram(s, t) do
+    s |> String.split("", trim: true) |> Enum.sort == t |> String.split("", trim: true) |> Enum.sort
+  end
+end
diff --git a/valid-anagram/saysimple.py b/valid-anagram/saysimple.py
@@ -0,0 +1,11 @@
+"""
+https://leetcode.com/problems/valid-anagram/
+"""
+# - time complexity : O(n)
+# - space complexity : O(n)
+
+from collections import Counter
+
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        return Counter(s) == Counter(t)
diff --git a/valid-anagram/wclee2265.cpp b/valid-anagram/wclee2265.cpp
diff --git a/valid-palindrome/Bumsu-Yi.py b/valid-palindrome/Bumsu-Yi.py
diff --git a/valid-palindrome/Leo.py b/valid-palindrome/Leo.py
diff --git a/valid-palindrome/bky373.java b/valid-palindrome/bky373.java
diff --git a/valid-palindrome/han.exs b/valid-palindrome/han.exs
diff --git a/valid-palindrome/saysimple.py b/valid-palindrome/saysimple.py
diff --git a/valid-palindrome/wclee2265.cpp b/valid-palindrome/wclee2265.cpp
