Merge branch 'DaleStudy:main' into main

Author: sadie100

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

@@ -0,0 +1,16 @@
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        """
+	지금까지 본 가격 중 가장 작은 값을 계속 저장하고
+        현재 가격에서 그 최소값을 뺀 값으로 최대 이익을 갱신합니다.
+        한 번 순회하면서 최대 profit을 찾는 방식입니다
+        """
+        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
+

climbing-stairs/ppxyn1.py

@@ -1,6 +1,33 @@
 # idea: DP
-# I'm not always sure how to approach DP problems. I just try working through a few examples step by step and then check that it would be DP.
-# If you have any suggestions for how I can come up with DP, I would appreciate your comments :)
+# Time Complexity : O(n)
+'''
+n = 4
+-------------------------------
+(dp[3] + 1step)
+1step + 1step + 1step + 1step 
+1step + 2step + 1step
+2step + 1step + 1step
+
+(dp[2] + 2step)
+1step + 1step + 2step
+2step + 2step
+
+================================
+n = 5
+--------------------------------
+(dp[4] + 1step)
+1step + 1step + 1step + 1step + 1step
+1step + 2step + 1step + 1step
+1step + 1step + 2step + 1step
+2step + 1step + 1step + 1step
+2step + 2step + 1step
+
+(dp[3] + 2step)
+1step + 2step + 2step
+2step + 1step + 2step
+1step + 1step + 1step + 2step
+'''
+
 
 class Solution:
     def climbStairs(self, n: int) -> int:
@@ -9,7 +36,6 @@ def climbStairs(self, n: int) -> int:
         dp = [0] * (n+1)
         dp[2], dp[3] = 2, 3
 
-        #for i in range(4, n): error when n=4       
         for i in range(4, n+1):
             dp[i] = dp[i-1] + dp[i-2]
 

contains-duplicate/01-binary.js

@@ -0,0 +1,7 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function (nums) {
+  return nums.length !== [...new Set(nums)].length;
+};

contains-duplicate/OstenHun.cpp

@@ -0,0 +1,145 @@
+/*
+    Problem:
+    Given an integer array nums, 
+    return true if any value appears at least twice in the array, 
+    and return false if every element is distinct.
+
+    Input: nums = [1,2,3,1]
+    Output: true
+
+    Constraints:
+    1 <= nums.length <= 10^5
+    -10^9 <= nums[i] <= 10^9
+*/
+
+// 처음 생각한 코드
+/*
+#include <iostream>
+#include <vector>
+using namespace std;
+
+class Solution {
+public:
+    bool containsDuplicate(vector<int>& nums) {
+        for (int i = 0; i < nums.size(); i++) {
+            for (int j = i+1; j < nums.size(); j++) {
+                if (nums[i]==nums[j]) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+};
+
+int main() {
+    vector<int> arr;
+    int sz;
+    cin >> sz;
+    for (int i = 0; i < sz; i++) {
+        int nm;
+        cin >> nm;
+        arr.push_back(nm);
+    }
+
+
+    Solution s;\
+    if (s.containsDuplicate(arr))
+        cout << "true";
+    else 
+        cout << "false";
+
+    return 0;
+}
+*/
+
+// O(n^2) 시간 복잡도를 개선해보자
+/*
+    set 을 이용해서 중복이 있다면 배열의 길이가 줄어들테니
+    이를 통해 중복을 판단할 수 있다고 생각했다.
+*/
+/*
+#include <iostream>
+#include <vector>
+#include <set>
+#include <algorithm>
+using namespace std;
+
+class Solution {
+public: 
+    bool containsDuplicate(vector<int>& nums) {
+        // set과 유사하게 만들기 위해서 사용
+        sort(nums.begin(), nums.end());
+        for (size_t i = 1; i < nums.size(); i++) {
+            if (nums[i] == nums[i-1]) return true;
+        }
+        return false;
+    }
+};
+
+
+int main() {   
+    size_t sz;
+    cin >> sz;
+
+    vector<int> arr;
+    for (int i = 0; i < sz; i++) {
+        int num;
+        cin >> num;
+        arr.push_back(num);
+    }
+
+    Solution sol;
+    if (sol.containsDuplicate(arr)) {
+        cout << "true";
+    } else {
+        cout << "false";
+    }
+}
+*/
+
+// 이보다 더 좋은 방법이 있다고 gpt의 리뷰가 있었다.
+/*
+    unordered_set<int> 를 이용한다.
+    해시 테이블 자료구조를 이용하여 구현 되어 있는 것.
+    정렬은 못하지만 탐색하는데에 O(1) 이라는 장점이 있어 이를 활용한다.
+    -> 빠른 탐색 굿
+*/
+
+
+#include <iostream>
+#include <unordered_set>
+#include <vector>
+using namespace std;
+
+class Solution {
+public:
+    bool containsDuplicate(vector<int>& nums) {
+        unordered_set<int> copy_set;
+        for (int x : nums) {
+            if (copy_set.count(x)) return true;
+            copy_set.insert(x);
+        }
+        return false;
+    }
+};
+
+int main() {
+    int n;
+    cin >> n;
+
+    vector<int> nums;
+    nums.reserve(n);
+
+    for (int i = 0; i < n; i++) {
+        int x;
+        cin >> x;
+        nums.push_back(x);
+    }
+
+    Solution sol;
+    cout << (sol.containsDuplicate(nums) ? "true" : "false");
+
+    return 0;
+}

contains-duplicate/TreeStone94.py

@@ -0,0 +1,6 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        if len(set(nums)) == len(nums):
+            return False
+        else:
+            return True

contains-duplicate/Yu-Won.js

@@ -0,0 +1,22 @@
+/**
+ * 문제: https://leetcode.com/problems/contains-duplicate/
+ *
+ * 요구사항:
+ * nums: number[]를 Input 으로 받았을 때
+ * 중복된 값이 있을 경우 true 없다면 false 를 반환
+ *
+ * 해시맵 이용
+ * */
+
+const containsDuplicate = (nums) => {
+    const set = new Set();
+
+    for(const num of nums) {
+        if(set.has(num)) {
+            return true;
+        }
+        set.add(num);
+    }
+    return false;
+
+}

contains-duplicate/acious.kt

@@ -0,0 +1,16 @@
+class Solution {
+    // 1 <= nums.length <= 10^5
+    // Integer.MIN_VALUE(2,147,483,647) < -10^9 <= nums[i] <= 10^9 < Integer.MAX_VALUE(2,147,483,647)
+    // HashSet에 아이템을 하나씩 넣으면서 이미 존재하는 아이템이 있으면 true, 없으면 false
+    // 시간복잡도 : O(n), 공간복잡도 : O(n)
+    fun containsDuplicate(nums: IntArray): Boolean {
+        val set = HashSet<Int>()
+        for (num in nums) {
+            if (set.contains(num)) {
+                return true
+            }
+            set.add(num)
+        }
+        return false
+    }
+}

contains-duplicate/doh6077.py

@@ -1,10 +1,7 @@
+# https://leetcode.com/problems/contains-duplicate/description/
 
-# set에 저장하면서 중복 여부 확인하기
 class Solution:
-    def containsDuplicate(self, nums: list[int]) -> bool:
-        hashset = set()
-        for i in nums:
-            if i in hashset:
-                return True
-            hashset.add(i)
-        return False
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        # Create a set to store unique numbers from nums
+        nums_set = set(nums)
+        return len(nums_set) != len(nums)

contains-duplicate/dongzoolee.ts

@@ -0,0 +1,4 @@
+function containsDuplicate(nums: number[]): boolean {
+  const sets = new Set<number>(nums);
+  return sets.size < nums.length;
+}

contains-duplicate/grapefruit13.ts

@@ -0,0 +1,16 @@
+/**
+ * @description nums 배열에서 중복 숫자 확인
+ * @param nums - 숫자 배열
+ * @returns boolean - 중복 숫자 여부
+ */
+const containsDuplicate = (nums: number[]) => {
+  const hasSeen = new Set<number>();
+
+  for (const num of nums) {
+    if (hasSeen.has(num)) {
+      return true;
+    }
+    hasSeen.add(num);
+  }
+  return false;
+};