Merge branch 'DaleStudy:main' into main

Author: printjin-gmailcom

3sum/jiji-hoon96.ts

@@ -0,0 +1,71 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ *
+ * 풀이 1
+ *
+ * 이렇게 푸니까 시간복잡도 O(n^3) / 공간복잡도 O(n) 라서 복잡한 예시에는 time limit 이 발생함
+ * 개선해보자..
+ *
+ * function threeSum(nums: number[]): number[][] {
+ *  nums.sort((a, b) => a - b);
+ *     let result = []
+ *     for (let i= 0; i<nums.length; i++){
+ *         for(let j= i+1 ; j <nums.length; j++){
+ *             for (let k = j+1; k<nums.length; k++){
+ *                 if(nums[i]+nums[j]+nums[k]===0){
+ *                     result.push([nums[i], nums[j], nums[k]]);
+ *                 }
+ *             }
+ *         }
+ *     }
+ *
+ *     return Array.from(
+ *         new Set(result.map(item => JSON.stringify(item))),
+ *         str => JSON.parse(str)
+ *     );
+ *     }
+ *
+ *  풀이 2
+ *
+ *  투포인터를 활용해보자.
+ *  아래처럼 문제를 풀게되면 시간복잡도 O(n^2) / 공간복잡도 O(1) 이다.
+ *  시공간 복잡도가 줄긴하지만 메모리 사용량과 큰 숫자를 다룰 때 성능이 매우 좋다!
+ */
+
+
+function threeSum(nums: number[]): number[][] {
+    let result : number[][] = []
+    nums.sort((a, b) => a - b);
+    const n = nums.length;
+
+    for(let first = 0; first<n-2; first++){
+        // 첫번째가 양수면 0이 될 수 없음
+        if(nums[first] > 0) break;
+
+        //중복된 수는 건너뜀
+        if(first > 0 && nums[first]===nums[first-1]) continue;
+
+        let left = first + 1;
+        let right = n-1;
+
+        while(left < right){
+            const sum = nums[first] +nums[left] + nums[right];
+
+            if(sum < 0){
+                left ++
+            }else if(sum > 0){
+                right --;
+            }else{
+                result.push([nums[first],nums[left],nums[right]]);
+                // left, left+1 이 같을 때 중복된 수는 건너뜀
+                while(left < right && nums[left] === nums[left+1]) left++;
+                // right, right+1 이 같을 때 중복된 수는 건너뜀
+                while(left < right && nums[right] === nums[right-1]) right--;
+                left++;
+                right--;
+            }
+        }
+    }
+    return result;
+}

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;
+}

climbing-stairs/jiji-hoon96.ts

@@ -0,0 +1,37 @@
+/**
+ * @param n
+ *
+ * dp, 슬라이딩 윈도우 사용해서 풀 수 있다.
+ *
+ * 공간 복잡도를 줄이기 위해서 아래와같이 슬라이딩을 활용할 수 있다.
+ *
+ * function climbStairs(n: number): number {
+ *     if (n <= 2) return n;
+ *
+ *     let first = 1;  // 1계단을 오르는 방법 수
+ *     let second = 2; // 2계단을 오르는 방법 수
+ *
+ *     for (let i = 3; i <= n; i++) {
+ *         let current = first + second;
+ *         first = second;
+ *         second = current;
+ *     }
+ *
+ *     return second;
+ * }
+ */
+
+
+function climbStairs(n: number): number {
+    if(n <= 2) return n;
+
+    let dp: number[] = new Array(n+1);
+    dp[1] = 1;
+    dp[2] = 2;
+
+    for(let i=3;i<=n;i++){
+        dp[i] = dp[i-1] +dp[i-2];
+    }
+
+    return dp[n]
+};

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/JisuuungKim.py

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

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;
+        }
+    };