Merge branch 'DaleStudy:main' into main

Author: eunhwa99

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/RiaOh.js

@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function (nums) {
+  let count = [nums[0]];
+  for (let i = 1; i < nums.length; i++) {
+    if (count.includes(nums[i])) {
+      return true;
+    } else {
+      count.push(nums[i]);
+    }
+  }
+  return false;
+};

contains-duplicate/b41-41.ts

@@ -0,0 +1,15 @@
+// nums에 중복이 있는 지 확인하는 것
+// array써서 시간 통과 못했다가 Set 객체로 변경해서 통과
+function containsDuplicate(nums: number[]): boolean {
+    const numSet = new Set();
+
+    for(let num of nums) {
+        if(numSet.has(num)) {
+            return true;
+        } else {
+            numSet.add(num);
+        }
+    }
+
+    return false;
+};

contains-duplicate/byol-han.js

@@ -0,0 +1,9 @@
+// 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.
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function (nums) {
+  const uniqueSet = new Set(nums);
+  return uniqueSet.size !== nums.length;
+};

contains-duplicate/choidabom.ts

@@ -0,0 +1,24 @@
+// https://leetcode.com/problems/contains-duplicate/description/
+
+// TC: O(n)
+// SC: O(n)
+
+function containsDuplicate(nums: number[]): boolean {
+  const set = new Set(nums);
+  return set.size !== nums.length;
+}
+
+function containsDuplicate(nums: number[]): boolean {
+  const set = new Set();
+
+  for (const num of nums) {
+    if (set.has(num)) {
+      return true;
+    }
+    set.add(num);
+  }
+
+  return false;
+}
+
+console.log(containsDuplicate([1, 1, 1, 3, 3, 4, 3, 2, 4, 2]));

contains-duplicate/crumbs22.cpp

@@ -0,0 +1,22 @@
+#include <iostream>
+#include <vector>
+#include <unordered_set>
+
+using namespace std;
+
+/*
+	TC: O(n)
+		벡터 nums의 모든 요소를 해시 테이블에 삽입하는 과정에서 O(n)만큼 소요됨	
+	SC: O(n)
+
+	풀이 방법 : nums의 중복요소를 거른 uset을 만들고, 
+				nums와 uset의 크기가 서로 다르다면 nums에 중복 요소가 하나 이상 존재한다.
+*/
+
+class Solution {
+public:
+    bool containsDuplicate(vector<int>& nums) {
+		unordered_set<int> uset(nums.begin(), nums.end());
+		return (nums.size() != uset.size());
+    }
+};

contains-duplicate/eunice-hong.ts

@@ -0,0 +1,15 @@
+
+/**
+ * Determines if the array contains any duplicate values.
+ * Uses a Set to track seen numbers for O(n) time complexity.
+ *
+ * @param nums - An array of integers.
+ * @returns `true` if there are duplicates, `false` otherwise.
+ *
+ * Time Complexity: O(n)
+ * Space Complexity: O(n)
+ */
+function containsDuplicate(nums: number[]): boolean {
+  let numSet = new Set(nums);
+  return numSet.size != nums.length;
+};

contains-duplicate/grapefruitgreentealoe.js

@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+
+/**
+ * 문제설명: 2개 이상 반복되는 값이 있으면 true, 모두 반복되지 않으면 false.
+
+제한사항
+ 1 <= nums.length <= 10^5
+-109 <= nums[i] <= 109
+ */
+
+var containsDuplicate = function (nums) {
+  const numberSet = new Set();
+  //시간 복잡도 O(n)
+  for (let i of nums) {
+    if (!numberSet.has(i)) {
+      //공간복잡도 O(n)
+      numberSet.add(i);
+    } else {
+      return true;
+    }
+  }
+  return false;
+};

contains-duplicate/haung921209.md

@@ -0,0 +1,37 @@
+
+
+# cpp stl
+```cpp
+class Solution {
+public:
+    bool containsDuplicate(vector<int>& nums) {
+        set<int> numSet(nums.begin(), nums.end());
+        return numSet.size() != nums.size();
+    }
+};
+```
+
+- set으로 단순비교. 편리하나, 정렬에 비해 시간이 오래 걸림.
+- unordered_set을 쓰면 set 방식에서 조금 더 빠를 수는 있음
+
+```cpp
+class Solution {
+public:
+    bool containsDuplicate(vector<int>& nums) {
+        sort(nums.begin(), nums.end());
+        for(int i=0;i<nums.size()-1;i++){
+            if(nums[i]==nums[i+1]){
+                return true;
+            }
+        }
+        return false;
+    }
+};
+```
+
+- 둘 다 O(n logn)의 시간 복잡도이나, 자료 특성 상 정렬이 더 빠름
+
+
+
+
+