Merge branch 'DaleStudy:main' into main

Author: choidabom

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

house-robber/heypaprika.py

@@ -0,0 +1,19 @@
+# Big-O 예상 : O(n)
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        a = [0] * len(nums)
+        
+        if len(nums) == 1:
+            return nums[0]
+        elif len(nums) == 2:
+            return max(nums[0], nums[1])
+            
+        a[0] = nums[0]
+        a[1] = nums[1]
+        a[2] = max(a[0] + nums[2], a[1])
+
+        for i in range(3, len(nums)):
+            a[i] = max(a[i-3], a[i-2]) + nums[i]
+
+        return max(a)
+

house-robber/mike2ox.ts

@@ -0,0 +1,25 @@
+/**
+ * Source: https://leetcode.com/problems/house-robber/
+ * 풀이방법: DP를 이용하여 집을 털 때 최대값을 구함
+ * 시간복잡도: O(n)
+ * 공간복잡도: O(n)
+ *
+ * 생각나는 풀이방법
+ */
+function rob(nums: number[]): number {
+  if (nums.length === 0) return 0;
+  if (nums.length === 1) return nums[0];
+  if (nums.length === 2) return Math.max(nums[0], nums[1]);
+
+  let prev = nums[0];
+  let maxResult = Math.max(nums[0], nums[1]);
+  let current = 0;
+
+  // 남은 집을 순회하면서 최대값을 구함
+  for (let i = 2; i < nums.length; i++) {
+    current = Math.max(maxResult, prev + nums[i]);
+    prev = maxResult;
+    maxResult = current;
+  }
+  return maxResult;
+}

house-robber/neverlish.go

@@ -0,0 +1,44 @@
+// 시간복잡도: O(n)
+// 공간복잡도: O(n)
+
+package main
+
+import (
+	"testing"
+)
+
+func Test(t *testing.T) {
+	result1 := rob([]int{1, 2, 3, 1})
+
+	if result1 != 4 {
+		t.Fatal("failed test1")
+	}
+
+	result2 := rob([]int{2, 7, 9, 3, 1})
+
+	if result2 != 12 {
+		t.Fatal("failed test2")
+	}
+}
+
+func rob(nums []int) int {
+	length := len(nums)
+
+	if length == 0 {
+		return 0
+	}
+	if length == 1 {
+		return nums[0]
+	}
+
+	moneys := make([]int, length)
+
+	moneys[0] = nums[0]
+	moneys[1] = max(nums[0], nums[1])
+
+	for position := 2; position < length; position++ {
+		moneys[position] = max(moneys[position-1], moneys[position-2]+nums[position])
+	}
+
+	return moneys[length-1]
+}

longest-consecutive-sequence/gwbaik9717.js

@@ -0,0 +1,30 @@
+// Time complexity: O(n)
+// Space complexity: O(n)
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var longestConsecutive = function (nums) {
+  let answer = 0;
+  const consecutiveDict = new Map();
+
+  for (const num of nums) {
+    consecutiveDict.set(num, true);
+  }
+
+  for (const num of nums) {
+    if (consecutiveDict.has(num - 1)) {
+      continue;
+    }
+
+    let length = 1;
+    while (consecutiveDict.has(num + length)) {
+      length++;
+    }
+
+    answer = Math.max(answer, length);
+  }
+
+  return answer;
+};