Merge branch 'DaleStudy:main' into main

Author: eunhwa99

contains-duplicate/HerrineKim.js

@@ -0,0 +1,17 @@
+// 시간복잡도: O(n)
+
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function (nums) {
+  const seen = new Set();
+  for (let num of nums) {
+    if (seen.has(num)) {
+      return true; // 중복 발견
+    }
+    seen.add(num);
+  }
+  return false; // 모든 요소가 고유
+};
+

contains-duplicate/HodaeSsi.py

@@ -0,0 +1,11 @@
+from typing import List
+
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        dict = {}
+        for num in nums:
+            dict[num] = dict.get(num, 0) + 1
+            if dict[num] > 1:
+                return True
+        return False
+

contains-duplicate/Jay-Mo-99.py

@@ -0,0 +1,23 @@
+class Solution(object):
+    def containsDuplicate(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: bool
+        """
+        #해석
+        #sets는 복수 요소를 허용하지 않는다(sets don't allow duplicate elements.)
+        #만약 set에 기반된 list가 기존 nums와 길이가 다르다면 duplicate element가 있었다는 뜻이다. 
+        #If the length of the set created from nums is different from the original list(nums), It means there are duplicates. 
+        
+        #Big O
+        #N: 주어진 배열 nums의 길이(Length of the input list nums)
+        
+        #Time Complexity: O(N)
+        #- set은 nums의 길이 n에 기반하여 생성된다(Creating a set from nums): O(N)
+        #- 생성된 list와 기존 nums와의 비교는 상수(Comparing the lengths between created list and original list) : O(1)
+        
+        #Space Complexity: O(N)
+        #-set은 nums의 길이에 의해 생성되므로 n에 영향받음(The set requires extra space depends on the size of nums) : O(N) 
+        return len(list(set(nums))) != len(nums) #set된 list와 기존 nums의 len이 일치하지 않는다면 true(duplicate), 아니면 false
+        
+

contains-duplicate/Real-Reason.kt

@@ -0,0 +1,10 @@
+package leetcode_study
+
+class SolutionContainsDuplicate {
+    fun containsDuplicate(nums: IntArray): Boolean {
+        val size = nums.size
+        val numsToSet = nums.toSet()
+
+        return size != numsToSet.size
+    }
+}

contains-duplicate/YeomChaeeun.ts

@@ -0,0 +1,36 @@
+function containsDuplicate(nums: number[]): boolean {
+
+    // 접근 (1) - 시간 복잡도가 매우 커서 실패
+    // const uniqueArr = nums.filter((item, index) => { return nums.indexOf(item) === index })
+    // console.log(uniqueArr)
+    //
+    // return nums.length !== uniqueArr.length;
+
+    // 접근 (2) - 양 옆의 값을 비교 =============
+    // if(nums.length === 1)
+    //     return false;
+    //
+    // // 정렬
+    // nums.sort()
+    //
+    // // 양 옆의 값을 비교
+    // for(let i = 0; i < nums.length; i++){
+    //     console.log(nums[i], nums[i+1])
+    //     if(nums[i] === nums[i+1]){
+    //         return true;
+    //     }
+    // }
+    // return false;
+
+    // 접근 (3) - obj를 이용 ================
+    let obj={}
+
+    for(let i = 0; i < nums.length; i++) {
+        if(obj[nums[i]]) {
+            return true;
+        }
+        obj[nums[i]] = 1;
+    }
+    return false;
+
+};

contains-duplicate/aa601.c

@@ -0,0 +1,60 @@
+#include <stdio.h>
+#include <stdbool.h>
+
+void	merge(int *nums, int left, int mid, int right)
+{
+	int	i;
+	int	j;
+	int	k;
+	int	leftArr[mid - left + 1];
+	int	rightArr[right - mid];
+
+	i = -1;
+	while (++i < mid - left + 1) // 왼쪽 분할된 부분 넣기
+		leftArr[i] = nums[left + i];
+	i = -1;
+	while (++i < right - mid) // 오른쪽 분할된 부분 넣기
+		rightArr[i] = nums[mid + i + 1];
+	i = 0;
+	j = 0;
+	k = left; // **** nums배열인덱스 => left부터 시작
+	// 나누어진 배열끼리 비교해서 nums배열 재배치
+	while ((i < mid - left + 1) && (j < right - mid)) {
+		if (leftArr[i] <= rightArr[j])
+			nums[k] = leftArr[i++];
+		else
+			nums[k] = rightArr[j++];
+		++k;
+	}
+	while (i < mid - left + 1) // left배열 남아있으면 마저 삽입
+		nums[k++] = leftArr[i++];
+	while (j < right - mid) // right배열 남아있으면 마저 삽입
+		nums[k++] = rightArr[j++];
+}
+
+void	mergeSort(int *nums, int left, int right) {
+	int	mid;
+
+	if (left < right)
+	{
+		mid = (left + right) / 2;
+		mergeSort(nums, left, mid); // 왼쪽분할
+		mergeSort(nums, mid + 1, right); // 오른쪽분할
+		merge(nums, left, mid, right);
+	}
+}
+
+bool containsDuplicate(int* nums, int numsSize) {
+	int	i;
+
+	mergeSort(nums, 0, numsSize - 1);
+	i = -1;
+	while (++i + 1 < numsSize) {
+		if (nums[i] == nums[i + 1])
+			return (true);
+	}
+	return (false);
+}
+
+
+

contains-duplicate/donghyeon95.java

@@ -0,0 +1,31 @@
+import java.util.*;
+
+class Solution {
+	public boolean containsDuplicate(int[] nums) {
+		/*
+		* -- 풀이 --
+		* nums를 순회하면서 HashSet에 데이터를 넣어서 중복되었는 지 확인한다.
+		*
+		* -- 시간 복잡도 --
+		* 길이 N인 nums를 순환하는데 대한 시간 복잡도 => O(N)
+		* hashSet의 add에 대한 시간 복잡도 => O(1)
+		* 전체 시간 복잡도 O(1)*O(N) =O(n)
+		* ------------------------------------------
+		*
+		* -- 공간 복잡도 --
+		* 길이 N인 nums를 넣을 Hashset이 있어야 하기에 O(N)
+		* -------------------------------------------
+		*/
+
+		// 중복을 확인할 수 있는 set 선언
+		HashSet<Integer> hashSet = new HashSet<>();
+
+		for (int num: nums) {
+			// set에 있다면
+			if (!hashSet.add(num)) return true;
+		}
+
+		return false;
+	}
+}
+

contains-duplicate/higeuni.js

@@ -0,0 +1,10 @@
+// 풀이
+// Set으로 중복 제거 후 nums와 길이 비교
+
+// TC : O(N)
+// SC : O(N)
+
+var containsDuplicate = function(nums) {
+  return new Set(nums).size !== nums.length
+};
+

contains-duplicate/imsosleepy.java

@@ -0,0 +1,15 @@
+// 중복제거를 위해 set을 적극적으로 활용해야할 듯...
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        Set<Integer> numSet = new HashSet<>();
+
+        for (int num : nums) {
+            if (numSet.contains(num)) {
+                return true;
+            }
+            numSet.add(num);
+        }
+
+        return false;
+    }
+}

contains-duplicate/jungsiroo.py

@@ -0,0 +1,18 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        # Slow - tc : O(n) / sc : O(1)
+		
+        """return len(set(nums)) != len(nums)"""
+
+        # Fast - tc : O(n) / sc : O(n)
+        check = set()
+        
+        for num in nums:
+            if num in check:
+                return True
+            check.add(num)
+        
+        return False
+
+
+