Merge branch 'DaleStudy:main' into main

Author: taurus09318976

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

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

contains-duplicate/krokerdile.js

@@ -0,0 +1,48 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+
+/**
+ * 1차 풀이
+ * - Map을 사용하여 각 숫자의 개수를 세는 방법
+ */
+var containsDuplicate = function(nums) {
+    let dict = new Map();
+
+    nums.forEach((num)=>{
+        if(dict.has(num)){
+            dict.set(num, dict.get(num)+1);
+        }else{
+            dict.set(num, 1);
+        }
+    })
+
+    for (const num of nums) {
+        if(dict.get(num) >= 2){
+            return true;
+        }
+    }
+    return false;
+};
+
+/**
+ * 2차풀이
+ * - Map을 사용하여 각 숫자의 개수를 세는 방법
+ * - forEach를 사용하지 않고 for of문을 사용하여 반복문을 돌리는 방법 
+ */
+var containsDuplicate = function(nums) {
+    let dict = new Map();
+
+    for (const num of nums) {
+         if(dict.has(num)){
+            dict.set(num, dict.get(num)+1);
+        }else{
+            dict.set(num, 1);
+        }
+        if(dict.get(num) >= 2){
+            return true;
+        }
+    }
+    return false;
+};

contains-duplicate/lhc0506.js

@@ -0,0 +1,10 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function(nums) {
+    const numsSet = new Set();
+    nums.forEach(num => numsSet.add(num));
+
+    return nums.length !== numsSet.size;
+};

contains-duplicate/mmyeon.js

@@ -0,0 +1,14 @@
+/**
+ *
+ * 접근 방법 :
+ *  - set 자료구조에 nums 값 담아서 set의 크기와 배열의 길이를 비교하기
+ *
+ * 시간복잡도 : O(n)
+ *  - nums 배열을 순회해서 set에 저장하니까 O(n)
+ *
+ * 공간복잡도 : O(n)
+ *  - nums 배열의 길이만큼 set에 담으니까 O(n)
+ */
+function containsDuplicate(nums: number[]): boolean {
+  return nums.length !== new Set(nums).size;
+}

contains-duplicate/mmyeon.ts

@@ -0,0 +1,3 @@
+class Solution:
+    def containsDuplicate(self, nums): 
+        return len(nums) != len(set(nums))

contains-duplicate/printjin-gmailcom.py

@@ -0,0 +1,37 @@
+# https://leetcode.com/problems/contains-duplicate/
+
+from typing import List
+
+class Solution:
+    def containsDuplicate1(self, nums: List[int]) -> bool:
+        """
+        [Complexity]
+            - TC: O(n) (set(nums) 시 원소를 복사하는 데에 O(n), len()은 O(1))
+            - SC: O(n)
+
+        [Approach]
+            set(hash map)을 이용하여 중복을 제거한 결과의 길이를 원본 리스트의 길이와 비교하면 된다.
+        """
+
+        return len(nums) != len(set(nums))
+
+
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        """
+        [Complexity]
+            - TC: O(n) (iteration)
+            - SC: O(n)
+
+        [Approach]
+            nums를 순회하면서 set(hash map)에 등장했던 원소를 add 하고, 동일한 원소가 발견되면 True를 반환한다.
+            nums 전체를 순회하면서 동일한 원소가 없었다면 False를 반환한다.
+        """
+
+        seen = set()
+
+        for num in nums:    # -- O(n)
+            if num in seen: # -- O(1)
+                return True
+            seen.add(num)
+
+        return False

contains-duplicate/seungriyou.py

@@ -0,0 +1,54 @@
+/**
+ * [Problem]: [198] House Robber
+ * (https://leetcode.com/problems/house-robber/description/)
+ */
+function rob(nums: number[]): number {
+    // 시간 복잡도 O(2^n)
+    // 공간 복잡도 O(n)
+    // 시간 초과
+    function recursionFunc(nums: number[]): number {
+        function getMax(start: number): number {
+            if (nums.length - 1 < start) return 0;
+            return Math.max(nums[start] + getMax(start + 2), getMax(start + 1));
+        }
+
+        return getMax(0);
+    }
+
+    // 메모이제이션
+    // 시간복잡도 O(n)
+    // 공간복잡도 O(n)
+    function memoizationFunc(nums: number[]): number {
+        let memoArr = new Array(nums.length).fill(-1);
+        function getMax(start: number): number {
+            if (nums.length - 1 < start) return 0;
+            if (memoArr[start] !== -1) return memoArr[start];
+
+            memoArr[start] = Math.max(nums[start] + getMax(start + 2), getMax(start + 1));
+
+            return memoArr[start];
+        }
+
+        return getMax(0);
+    }
+
+    // DP
+    // 시간복잡도 O(n)
+    // 공간복잡도 O(1)
+    function dpSolution(nums: number[]): number {
+        if (nums.length === 1) return nums[0];
+
+        let prev2 = 0;
+        let prev1 = 0;
+
+        for (let num of nums) {
+            let current = Math.max(prev1, prev2 + num);
+            prev2 = prev1;
+            prev1 = current;
+        }
+
+        return prev1;
+    }
+
+    return dpSolution(nums);
+}

house-robber/HoonDongKang.ts

@@ -0,0 +1,22 @@
+class Solution {
+    public:
+        int rob(vector<int>& nums) {
+            int n = nums.size();
+
+            if(n == 0) return 0;
+            if(n == 1) return nums[0];
+            if(n == 2) return max(nums[0], nums[1]);
+
+            int prev2 = nums[0];
+            int prev1 = max(nums[0], nums[1]);
+            
+
+            for(int i = 2; i < n; i++){
+                int curr = max(prev1, prev2 + nums[i]);
+                prev2 = prev1;
+                prev1 = curr;
+            }
+
+            return prev1;
+        }
+    };