Merge branch 'DaleStudy:main' into main

Author: KwonNayeon

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/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/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

contains-duplicate/Tessa1217.java

@@ -0,0 +1,21 @@
+import java.util.HashSet;
+import java.util.Set;
+
+class Solution {
+
+    /** 217. 중복된 수
+      * 정수 배열 nums가 주어졌을 때 배열 요소 중 한 개 이상이 두 번 이상 중복되어
+      * 나타는 경우 true를, 모든 배열의 요소가 고유한 경우 false를 반환
+      */
+    public boolean containsDuplicate(int[] nums) {
+
+        Set<Integer> distincts = new HashSet<>();
+
+        for (int i = 0; i < nums.length; i++) {
+            distincts.add(nums[i]);
+        }
+
+        return distincts.size() != nums.length;
+    }
+}
+

contains-duplicate/Ujoonnee.java

@@ -0,0 +1,24 @@
+import java.util.HashSet;
+import java.util.Set;
+
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        Set<Integer> numberSet = new HashSet<>();
+        for(int number : nums) {
+            if(numberSet.contains(number)) {
+                return true;
+            }
+
+            numberSet.add(number);
+        }
+        return false;
+    }
+}
+
+/*
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        return Arrays.stream(nums).distinct().count() != nums.length;
+    }
+}
+*/

contains-duplicate/Yn3-3xh.java

@@ -0,0 +1,27 @@
+/*
+[문제풀이]
+time: O(N), space: O(N)
+- 같은 수가 하나라도 있으면 true
+- 모든 수가 다르면 false
+
+[회고]
+ArrayList vs Set
+ArrayList: O(N^2), 매번 리스트를 처음부터 검색해야 하며, n번 반복
+Set      : O(N)  , 내부적으로 해시 테이블을 사용하여 중복 확인을 O(1)에 수행
+따라서 중복 검사에서 Set 더 효율적
+
+set.add()의 return 자료형은 boolean 이다.
+이후에는 if(!set.add()) 처럼 사용해도 좋을 듯.
+*/
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        Set<Integer> set = new HashSet<>();
+        for (int num : nums) {
+            if (set.contains(num)) {
+                return true;
+            }
+            set.add(num);
+        }
+        return false;
+    }
+}

contains-duplicate/YoungSeok-Choi.java

@@ -0,0 +1,19 @@
+import java.util.HashMap;
+import java.util.Map;
+
+class Solution {
+    // 시간복잡도 O(n)
+    public boolean containsDuplicate(int[] nums) {
+        Map<Integer, Boolean> dupMap = new HashMap<>();
+
+        for(int i = 0; i < nums.length; i++) {
+            if(dupMap.containsKey(nums[i])) {
+                return true;
+            }
+
+            dupMap.put(nums[i], true);
+        }
+
+        return false;
+    }
+}

contains-duplicate/ayosecu.py

@@ -0,0 +1,30 @@
+from typing import List
+
+class Solution:
+    """
+        - Time Complexity: O(n), n = len(nums)
+        - Space Complexity: O(N)
+            - N = len(set_check) = The number of unique numbers
+            - If there is no duplicated numbers, N = n
+    """
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        set_check = set()
+
+        for num in nums:
+            if num in set_check:
+                return True
+            else:
+                set_check.add(num)
+        
+        return False
+
+tc = [
+        ([1, 2, 3, 1], True),
+        ([1, 2, 3, 4], False),
+        ([1,1,1,3,3,4,3,2,4,2], True)
+    ]
+
+for i, (t, e) in enumerate(tc, 1):
+    sol = Solution()
+    result = sol.containsDuplicate(t)
+    print(f"TC {i} is Passed!" if result == e else f"TC {i} is Failed! - Expected: {e}, Result: {result}")

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/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/clara-shin.js

@@ -0,0 +1,31 @@
+/**
+ * 문제 파악: 배열에 중복된 요소가 있는지 확인하는 문제
+ * 만약 한 값이 배열에서 적어도 두 번 이상 나타난다면 true를, 모든 요소가 고유하다면 false를 반환
+ *
+ * 접근 방식:
+ * Set 객체를 사용하여 중복된 요소를 확인
+ * Set은 중복된 값을 허용하지 않기 때문에, 배열을 Set으로 변환한 후 길이를 비교하여 중복 여부를 확인
+ * 배열의 길이와 Set으로 변환한 후의 길이를 비교
+ * - 길이가 다르면 중복된 요소가 존재하므로 true 반환
+ * - 길이가 같으면 중복된 요소가 존재하지 않으므로 false 반환
+ * 시간 복잡도: O(n) - 배열을 한 번 순회하면서 Set에 요소를 추가하기 때문
+ * 공간 복잡도: O(n) - Set에 최대 n개의 요소를 저장해야 하기 때문
+ */
+
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function (nums) {
+  const uniqueSet = new Set(nums);
+  return uniqueSet.size < nums.length;
+};
+
+/**
+ * 내장메서드인 sort()를 사용하여 배열을 정렬한 후, 인접한 요소를 비교하여 중복된 요소가 있는지 확인하는 방법도 있다. -> 시간 복잡도 O(n log n)
+ *
+ * 성능비교:
+ * Set() 사용 : Runtime: ✨15ms, Memory: 68MB
+ * sort() 사용: Runtime: 69ms, Memory: 65.6MB
+ *
+ * */

contains-duplicate/doitduri.swift

@@ -0,0 +1,6 @@
+class Solution {
+    func containsDuplicate(_ nums: [Int]) -> Bool {
+        let numbericSet = Set(nums)
+        return numbericSet.count < nums.count
+    }
+}

contains-duplicate/eunhwa99.java

@@ -1,14 +1,15 @@
+import java.util.HashSet;
+
+// 공간 복잡도; O(n)
+// 시간 복잡도: O(1)
 class Solution {
     public boolean containsDuplicate(int[] nums) {
-         HashSet<Integer> seen = new HashSet<>();
+         HashSet<Integer> visited = new HashSet<>();
         for (int num : nums) {
-            if (!seen.add(num)) {
+            if (!visited.add(num)) {
                 return true;
             }
         }
-        
         return false;
-
-        
     }
 }

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