Merge branch 'DaleStudy:main' into main

Author: Zioq

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

contains-duplicate/neverlish.go

@@ -0,0 +1,33 @@
+// 시간복잡도: O(n)
+// 공간복잡도: O(n)
+
+package main
+
+import "testing"
+
+func Test(t *testing.T) {
+	result1 := containsDuplicate([]int{1, 2, 3, 1})
+
+	if result1 != true {
+		t.Fatal("failed test1")
+	}
+
+	result2 := containsDuplicate([]int{1, 2, 3, 4})
+
+	if result2 != false {
+		t.Fatal("failed test2")
+	}
+}
+
+func containsDuplicate(nums []int) bool {
+	data := make(map[int]bool)
+
+	for _, num := range nums {
+		if data[num] {
+			return true
+		} else {
+			data[num] = true
+		}
+	}
+	return false
+}

contains-duplicate/pmjuu.py

@@ -0,0 +1,3 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        return len(nums) != len(set(nums))

contains-duplicate/ysle0.go

@@ -0,0 +1,55 @@
+package contains_duplicate
+
+import "sort"
+
+/*
+1. 문제
+
+	주어진 int 배열 nums에 숫자가 중복되는 경우가 한 번이라도 있으면 true, 그렇지 않으면 false 를 리턴
+
+2. 풀이
+
+	고유값만 저장하는 set(go 에서는 map)의 성질을 활용하여
+	nums를 순회하며 set에 값이 있는지 없는지 체크하여
+	숫자가 중복되는 경우를 체크
+
+3. 분석
+  - 시간 복잡도: O(N)
+    nums 탐색: O(N)
+    배열 nums의 모든 원소를 단 한 번 순회
+    map 삽입, 탐색: O(1)
+    map의 내부 구현은 해시 테이블.
+    O(N)보다 작아 무시됨
+  - 공간 복잡도: O(N)
+    최악의 경우라도 사용공간은 nums 의 크기만큼 + nums의 모든 원소를 포함한 map
+*/
+func containsDuplicate(nums []int) bool {
+	seen := map[int]int{}
+
+	for _, n := range nums {
+		if _, ok := seen[n]; ok {
+			return true
+		}
+
+		seen[n] = 1
+	}
+
+	return false
+}
+
+func containsDuplicate_SortedApproach(nums []int) bool {
+	// early exit for small slices
+	if len(nums) < 2 {
+		return false
+	}
+
+	// sort in ascending order and check adjacent elements
+	sort.Ints(nums)
+	for i := 1; i < len(nums); i++ {
+		if nums[i] == nums[i-1] {
+			return true
+		}
+	}
+
+	return false
+}

house-robber/EcoFriendlyAppleSu.kt

@@ -0,0 +1,30 @@
+package leetcode_study
+
+/**
+ * DP를 사용한 문제 풀이.
+ * DP를 사용하지 않고 모든 경우의 수를 계산하여 최대 값을 구하려면 100!에 해당하는 연산이 필요하며, 이는 시간 초과를 초래합니다.
+ * 시간 복잡도 : O(n)
+ * -> 주어진 숫자 배열 만큼 반복 진행
+ * 공간 복잡도 : O(n)
+ * -> 숫자 배열만큼의 가중치를 담을 배열 필요
+ */
+fun rob(nums: IntArray): Int {
+    val dp = IntArray(nums.size)
+
+    if (nums.size == 1) {
+        return nums[0]
+    }
+
+    if (nums.size == 2) {
+        return max(nums[0], nums[1])
+    }
+
+    dp[0] = nums[0]
+    dp[1] = nums[1]
+    dp[2] = nums[2] + dp[0]
+
+    for (i in 3 until nums.size) {
+        dp[i] = max(dp[i-3], dp[i-2]) + nums[i]
+    }
+    return dp.max()
+}

house-robber/gwbaik9717.js

@@ -0,0 +1,18 @@
+// Time complexity: O(n)
+// Space complexity: O(n)
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function (nums) {
+  const n = nums.length;
+  const dp = Array.from({ length: n + 1 }, () => 0);
+  dp[1] = nums[0];
+
+  for (let i = 2; i < n + 1; i++) {
+    dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i - 1]);
+  }
+
+  return dp.at(-1);
+};