Merge branch 'DaleStudy:main' into main

Author: jinhyungrhee

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

@@ -0,0 +1,14 @@
+function maxProfit(prices: number[]): number {
+  let minPrice = Infinity;
+  let maxProfit = 0;
+  for (let i = 0; i < prices.length; i++) {
+    if (prices[i] < minPrice) {
+      minPrice = prices[i];
+    }
+
+    if (prices[i] - minPrice > maxProfit) {
+      maxProfit = prices[i] - minPrice;
+    }
+  }
+  return maxProfit;
+}

contains-duplicate/HISEHOONAN.swift

@@ -0,0 +1,17 @@
+//
+//  Contains_Duplicate.swift
+//  Algorithm
+//
+//  Created by 안세훈 on 3/31/25.
+//
+
+import Foundation
+
+class Solution {
+    func containsDuplicate(_ nums: [Int]) -> Bool {
+        return nums.count != Set(nums).count
+        //Set : 중복된 값을 갖지 않음.
+        //문제로 주어진 배열의 개수와 중복을 갖지않는 Set연산의 개수의 차이 비교
+        //비교 후 다르다면 true 같다면 false
+    }
+}

contains-duplicate/HoonDongKang.ts

@@ -0,0 +1,41 @@
+/**
+ * [Problem]: [217] Contains Duplicate
+ * (https://leetcode.com/problems/contains-duplicate/description/)
+ */
+
+function containsDuplicate(nums: number[]): boolean {
+  // 시간복잡도: O(n^2)
+  // 공간복잡도: O(1)
+  const doubleLoopFunc = (nums: number[]) => {
+    let isDuplicated = false;
+    for (let i = 0; i < nums.length; i++) {
+      for (let j = i + 1; j < nums.length; j++) {
+        if (nums[i] === nums[j]) isDuplicated = true;
+      }
+    }
+    return isDuplicated;
+  };
+
+  // 시간복잡도: O(n)
+  // 공간복잡도: O(n)
+  const setFunc = (nums: number[]) => {
+    const numsSet = new Set<number>(nums);
+
+    return nums.length !== numsSet.size;
+  };
+
+  // 시간복잡도: O(n)
+  // 공간복잡도: O(n)
+  const mapFunc = (nums: number[]) => {
+    const numsMap = new Map<number, boolean>();
+
+    for (const num of nums) {
+      if (numsMap.get(num)) return true;
+      numsMap.set(num, true);
+    }
+
+    return false;
+  };
+
+  return mapFunc(nums);
+}

contains-duplicate/JANGSEYEONG.js

@@ -0,0 +1,14 @@
+/*
+  시간복잡도: O(n) - new Set(nums)에서 배열 요소 순회하며 Set 생성 O(n) + 길이 비교 O(1)
+  - Set 자료구조는 중복된 값을 자동으로 제거
+*/
+
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function (nums) {
+  // Set으로 만들었을 때, 기존 배열과 사이즈가 다르면 중복이 제거된거임
+  const numsSet = new Set(nums);
+  return nums.length !== numsSet.size;
+};

contains-duplicate/Jeehay28.ts

@@ -0,0 +1,60 @@
+// Approach 3: HashSet (Using TypeScript Set)
+// ⏳ Time Complexity: O(n)
+// 💾 Space Complexity: O(n)
+
+function containsDuplicate(nums: number[]): boolean {
+
+    const seen = new Set<number>();
+
+    for (const num of nums) {
+        if (seen.has(num)) {
+            return true;
+        }
+        seen.add(num);
+    }
+
+    return false;
+
+};
+
+
+// Approach 2: Sorting + Scan
+// ⏳ Time Complexity: O(n * log(n)) ❌ (Faster than O(n^2), but still not optimal)
+// 💾 Space Complexity: O(1)
+
+// function containsDuplicate(nums: number[]): boolean {
+
+//     nums.sort();
+
+//     for (let i = 0; i < nums.length - 1; i++) {
+//         if (nums[i] === nums[i + 1]) {
+//             return true;
+//         }
+//     }
+
+//     return false;
+
+// };
+
+
+// Approach 1: Brute Force (O(n^2))
+// 🚨⏳ TLE (Time Limit Exceeded)!
+// ⏳ Time Complexity: O(n^2) ❌ (Inefficient for large inputs)
+// 💾 Space Complexity: O(1) ✅ (Great, no extra memory used!)
+
+// function containsDuplicate(nums: number[]): boolean {
+
+//     for (let i = 0; i < nums.length; i++) {
+//         for (let j = i + 1; j < nums.length; j++) {
+//             if (nums[i] === nums[j]) {
+//                 return true;
+//             }
+//         }
+//     }
+
+//     return false;
+
+// };
+
+
+

contains-duplicate/JiHyeonSu.py

@@ -0,0 +1,5 @@
+# 중복제거 후 길이 확인 문제
+# 시간복잡도 및 공간복잡도 O(n)
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        return len(nums) != len(set(nums))

contains-duplicate/JustHm.swift

@@ -0,0 +1,5 @@
+class Solution {
+    func containsDuplicate(_ nums: [Int]) -> Bool {
+        nums.count != Set(nums).count
+    }
+}

contains-duplicate/KwonNayeon.py

@@ -1,37 +1,23 @@
 """
-Title: 217. Contains Duplicate  
-Link: https://leetcode.com/problems/contains-duplicate/  
+Problem: 217. Contains Duplicate  
 
-Summary:
-    - 주어진 배열 `nums`에서 어떤 값이 한 번 이상 등장하면 True를 반환하고, 배열의 모든 값이 유일한 경우에는 False를 반환함
-    - Input: `nums = [1,2,3,1]`
-    - Output: `True`
+Constraints:
+- 1 <= nums.length <= 10^5
+- -10^9 <= nums[i] <= 10^9
 
-Conditions:
-    - 중복이 있으면: 배열에서 적어도 하나의 값이 두 번 이상 등장하면 `True` 반환
-    - 중복이 없으면: 배열의 모든 값이 유일하면 `False` 반환
-"""
+Time Complexity: O(n)
+- 배열을 한 번만 순회함
+- 집합에서 검색과 추가 연산은 평균적으로 O(1)
+- 총 n개 요소에 대해 각각 O(1) 연산 수행
 
-"""
-First Try
-Time Complexity:
-    - O(n) * O(n) = O(n^2): `for` 루프에서 `nums.count(i)`를 호출할 때마다 리스트를 순회하므로, 전체 시간 복잡도는 `O(n^2)`
-"""
-class Solution:
-    def containsDuplicate(self, nums: List[int]) -> bool:
-        for i in nums:
-            if nums.count(i) > 1:
-                return True
-        return False
-
-"""
-Second Try (set를 활용하여 이미 본 요소를 효율적으로 추적하는 방법)
-Time Complexity:
-    - O(n): `for` 루프에서 각 숫자에 대해 `in` 연산과 `add` 연산이 상수 시간 O(1)으로 처리되므로, 전체 시간 복잡도는 O(n)
+Space Complexity: O(n)
+- 최악의 경우 모든 요소를 집합에 저장
+- 추가 공간이 입력 배열 크기에 비례함
 """
 class Solution:
     def containsDuplicate(self, nums: List[int]) -> bool:
         seen = set()
+
         for i in nums:
             if i in seen:
                 return True

contains-duplicate/PDKhan.cpp

@@ -0,0 +1,15 @@
+class Solution {
+    public:
+        bool containsDuplicate(vector<int>& nums) {
+            unordered_map<int, int> map;
+    
+            for(int i = 0; i < nums.size(); i++){
+                map[nums[i]]++;
+                
+                if(map[nums[i]] == 2)
+                    return true;
+            }
+    
+            return false;
+        }
+    };

contains-duplicate/Sung-Heon.py

@@ -0,0 +1,9 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        temp = {}
+        for i in nums:
+            if temp.get(i):
+                return True
+            else:
+                temp[i] = True
+        return False