Merge branch 'DaleStudy:main' into main

Author: Zioq

contains-duplicate/Chaedie.py

@@ -0,0 +1,21 @@
+
+
+'''
+풀이:
+    중복된 요소가 있는지 찾는 문제입니다.
+
+    hash set 으로 중복을 제거하고
+    기존 nums 의 길이와 중복 제거된 nums_set 의 길이가 같은지 return 했습니다.
+
+시간 복잡도:
+    O(n) - has set 을 만드는 시간
+
+공간 복잡도:
+    O(n) - n개의 요소를 set에 담기 때문
+'''
+
+
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        nums_set = set(nums)
+        return len(nums_set) != len(nums)

contains-duplicate/EcoFriendlyAppleSu.kt

@@ -0,0 +1,13 @@
+package leetcode_study
+
+/**
+ * Set 자료 구조로 변경 후 원소의 개수를 비교해 문제 해결
+ * 시간 복잡도 : O(n)
+ * -> 모든 Array의 원소를 순회해야함.
+ * 공간 복잡도 : O(n)
+ * -> IntArray의 요소 개수에 비례하여 추가적인 공간이 필요함.
+ */
+fun containsDuplicate(nums: IntArray): Boolean {
+    val changeSet = nums.toSet()
+    return changeSet.size != nums.size
+}

contains-duplicate/GangBean.java

@@ -0,0 +1,12 @@
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        /***
+            compare length of array and length of set.
+            O(n) given that n is length of array nums
+        */
+        return nums.length > Arrays.stream(nums).boxed().collect(Collectors.toSet()).size();
+    }
+}

contains-duplicate/bus710.go

@@ -0,0 +1,21 @@
+// 주어진 배열을 선형 순회 하므로, 시간 복잡도와 공간 복잡도 모두 O(n)일 것으로 생각합니다.
+
+package week01
+
+// 주어진 배열 nums를 순회하며 준비한 맵에 표시를 하되,
+// - 키값에 해당하는 값이 없으면 맵의 해당 키값에 true를 저장하고
+// - 키값에 해당하는 값이 있으면 즉시 true를 반환.
+// - 순회 후에도 반환하지 않은 경우 중복이 발견되지 않았으므로 false를 반환.
+func containsDuplicate(nums []int) bool {
+	dup := make(map[int]bool, 0)
+	for _, n := range nums {
+		if _, ok := dup[n]; !ok {
+			dup[n] = true
+		} else {
+			return true
+		}
+	}
+
+	return false
+}
+

contains-duplicate/dalpang81.java

@@ -0,0 +1,11 @@
+//시간복잡도 : O(nlogn)
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        Arrays.sort(nums);
+        for(int i = 0; i < nums.length - 1; i++) {
+            if(nums[i] == nums[i+1])
+                return true;
+        }
+        return false;
+    }
+}

contains-duplicate/forest000014.java

@@ -0,0 +1,26 @@
+/*
+Runtime: 10 ms(Beats: 89.16 %)
+Time Complexity: O(n)
+- HashSet r/w : O(1)
+- nums iteration : ( O(1) + O(1) ) * n = O(n)
+
+Memory: 58.63 MB(Beats: 22.32 %)
+Space Complexity: O(n)
+*/
+
+
+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/gwbaik9717.js

@@ -0,0 +1,12 @@
+// Time complexity: O(n)
+// Space complexity: O(n)
+
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function (nums) {
+  const set = new Set(nums);
+
+  return set.size !== nums.length;
+};

contains-duplicate/heypaprika.py

@@ -0,0 +1,11 @@
+# Big-O 예상 : O(n)
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        num_dict = {}
+        for num in nums:
+            if num in num_dict:
+                return True
+            else:
+                num_dict[num] = 1
+        return False
+

contains-duplicate/limlimjo.js

@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function(nums) {
+
+    // 첫 번째 방법: filter + indexOf 사용 => indexOf(),filter() 각각 시간복잡도 O(n) 두 개가 중첩이므로 시간복잡도 O(n^2)
+    // Runtime: Time Limit Exceeded 발생
+    const method1 = function() {
+            const filterNums = nums.filter((item,index) => nums.indexOf(item) !== index);
+            return filterNums.length > 0;
+    }
+
+    // 두 번째 방법: Set 사용 => nums 배열을 set으로 변환할 때 한번씩 확인하면 되므로 시간복잡도 O(n)
+    // Runtime: 14ms
+    const method2 = function() {
+        const setNums = new Set(nums);
+        return setNums.size !== nums.length;
+    }
+
+    // 위 두 가지 방법 중 Set을 사용하는 것이 성능상 훨씬 나음
+    return method2();
+};

contains-duplicate/mike2ox.ts

@@ -0,0 +1,16 @@
+/**
+ * Source: https://leetcode.com/problems/contains-duplicate/
+ * 풀이방법: Set을 이용하여 중복된 값이 있는지 확인
+ * 시간복잡도: O(n)
+ * 공간복잡도: O(n)
+ *
+ * 생각나는 풀이방법
+ * 1. 단순하게 sorted를 이용하여 이전값과 비교하여 중복된 값이 있는지 확인
+ * 2. 정렬하지 않고 nums의 길이만큼의 배열을 만들어서 중복된 값이 있는지 저장하면서 확인
+ */
+function containsDuplicate(nums: number[]): boolean {
+  // 중복된 값이 없는 자료구조 Set 활용
+  const set = new Set<number>(nums);
+  // Set의 size와 nums의 length를 비교하여 중복된 값이 있는지 확인
+  return set.size !== nums.length;
+}