Merge branch 'DaleStudy:main' into main

Author: YeomChaeeun

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

longest-consecutive-sequence/EcoFriendlyAppleSu.kt

@@ -0,0 +1,57 @@
+package leetcode_study
+
+/**
+ * HashSet을 사용한 풀이.
+ * 시간 복잡도 O(n)
+ * -> Loop를 두 번 돌기 때문에 O(n^2)이라고 생각할 수 있으나 최악의 상황이여도 O(n + (n-1))로 O(n)이 됨.
+ * -> 1 부터 10억까지의 연속된 수가 Set 자료구조에 담겨 있고 최악의 상황으로 1이 마지막 순번에 뽑힌다고 가정했을 때, (Set은 순서가 존재하지 않음)
+ * -> 1 부터 Longest Count 하더라도 주어진 nums에서 n 번 set에서 10억 -1번을 순회하므로 O(n^2)이 아닌 O(n)이 됨.
+ */
+fun longestConsecutive(nums: IntArray): Int {
+    val numSet: HashSet<Int> = nums.toHashSet()
+    var longest = 0
+
+    for (num in nums) {
+        // 현재 요소보다 크기가 1 작은 숫자를 갖고 있다면 현재 요소는 최소값이 아니므로 다음으로 넘어감
+        if (numSet.contains(num -1)) {
+            continue
+        }
+        // 현재 요소보다 1 작은 연속된 숫자가 없으므로 현재 원소를 1 카운트 한 length 할당
+        var length = 1
+        while (numSet.contains(num + length)) {
+            length++
+        }
+        longest = max(longest, length)
+    }
+    return longest
+}
+
+/**
+ * Time Limit 발생.
+ * 시간 복잡도 O(n^2)
+ * -> nums 안에 존재하는 요소마다 중복을 포함한 Loop(while) 진행
+ */
+fun longestConsecutive01(nums: IntArray): Int {
+    // 결과를 담을 리스트
+    val resultList = mutableListOf<Int>()
+
+    // 1차 loop
+    for (i in nums.indices) {
+        var tempResult = 0
+        var currentNum = nums[i]
+        // 2차 loop
+        while (true) {
+            if (nums.contains(currentNum)) {
+                tempResult += 1
+                currentNum += 1
+            } else {
+                break
+            }
+        }
+        resultList.add(tempResult)
+    }
+    if (resultList.isEmpty()) {
+        return 0
+    }
+    return resultList.max()
+}

longest-consecutive-sequence/heypaprika.py

@@ -0,0 +1,22 @@
+# Big-O 예상 : O(nlog(n))
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        nums = sorted(list(set(nums)))
+        if len(nums) == 0:
+            return 0
+        elif len(nums) == 1:
+            return 1
+        cur_long = 1
+        longest = 1
+        for i, num in enumerate(nums):
+            if i == 0:
+                continue
+            else:
+                if nums[i-1] + 1 == nums[i]:
+                    cur_long += 1
+                    if longest < cur_long:
+                        longest = cur_long
+                else:
+                    cur_long = 1
+        return longest
+

longest-consecutive-sequence/ysle0.go

@@ -0,0 +1,72 @@
+package longest_consecutive_sequence
+
+import "slices"
+
+/*
+ 1. 문제
+    주어진 int 배열 nums에서 찾을 수 있는 가장 긴 연속된 원소의 길이 구하기
+
+ 2. 풀이
+    모든 수의 중복을 제거하고, 오름차순으로 정렬하여 연속된 원소의 부분을 찾기 위해서
+    배열을 순회하여 인덱스 고정~전진하며 다음 원소가 연속된 원소인지 체크를 반복
+
+3. 분석
+
+  - 시간 복잡도: O(N logN)
+    배열 정렬 O(N logN)
+    중복된 원소를 제거해주는 slices.Compact(nums): O(N)
+    2중 포문은 for 문 순회 index 를 같이 쓰므로 O(N)
+
+  - 공간 복잡도: O(N)
+*/
+func longestConsecutive(nums []int) int {
+	if len(nums) == 0 {
+		return 0
+	}
+
+	if len(nums) == 1 {
+		return 1
+	}
+
+	slices.Sort(nums)
+	nums = slices.Compact(nums)
+	// 중복을 제거하고 나서도 1개면 최장연속수는 1
+	if len(nums) == 1 {
+		return 1
+	}
+
+	cons := map[int]int{}
+	cursor := 0
+	for cursor < len(nums)-1 {
+		cons[cursor] = 1
+		wasConsecutive := false
+
+		// cursor 는 고정하고, innerCursor 를 돌림
+		innerCursor := cursor
+		for innerCursor+1 < len(nums) &&
+			nums[innerCursor]+1 == nums[innerCursor+1] {
+
+			cons[cursor]++
+			innerCursor++
+			wasConsecutive = true
+		}
+
+		if wasConsecutive {
+			cursor = innerCursor
+		}
+		cursor++
+	}
+
+	//tmp := make([]int, 0, len(cons))
+	tmp := make([]int, 0, len(cons))
+	for _, v := range cons {
+		tmp = append(tmp, v)
+	}
+
+	slices.SortFunc(
+		tmp,
+		func(a, b int) int {
+			return b - a
+		})
+	return tmp[0]
+}

top-k-frequent-elements/EcoFriendlyAppleSu.kt

@@ -0,0 +1,62 @@
+package leetcode_study
+
+/**
+ * 주어진 숫자들에서 빈도 수가 가장 큰 k 개의 숫자를 구하는 문제. map 자료구조를 사용해 해결
+ * 시간 복잡도 : O(nlogn)
+ * -> Int Array를 순회해 map에 담는 과정 O(n)
+ * -> 채워진 Map 자료구조에서 value 기준 내림차순으로 정렬 과정 O(nlogn)
+ * -> 정렬된 Map에서 K 만큼 값을 가져오는 과정 O(K). (k는 상수)
+ * 각 단계의 시간 복잡도를 더하면 : O(n) + O(nlogn) + O(k) -> O(nlogn)
+ * 공간 복잡도 : O(n)
+ * -> Int Array에 존재하는 유니크한 요소 만큼 필요함.
+ */
+fun topKFrequent(nums: IntArray, k: Int): IntArray {
+    val map = mutableMapOf<Int, Int>()
+
+    for (i in nums.indices) {
+        if (map.containsKey(nums[i])) {
+            val value = map[nums[i]]!!
+            map[nums[i]] = value + 1
+        } else {
+            map.putIfAbsent(nums[i], 1)
+        }
+    }
+    val sortedMap = map.toList().sortedByDescending { it.second }.toMap()
+    return sortedMap.entries.take(k).map { it.key }.toIntArray()
+}
+
+/**
+ * 주어진 수의 빈도수를 기준으로 숫자를 할당하고 내림차순으로 순회해 k 개의 숫자를 얻게 되면 답을 도출하는 방법
+ * 시간 복잡도 : O(n)
+ * -> Int Array를 순회해 map에 담는 과정 O(n)
+ * -> 빈도수 배열에 값을 채우는 과정 O(n)
+ * -> 빈도수 배열을 내림차순으로 순회해 k 개를 만족하면 답을 도출하는 과정 O(n).
+ * 이중 for loop 이지만 실제로는 빈도수가 유일한 숫자들만 고려되므로 k가 n보다 작거나 같은 경우에는 O(n)으로 가늠할 수 있음.
+ * 각 단계의 시간 복잡도를 더하면 : O(n) + O(n) + O(n) -> O(n)
+ * 공간 복잡도 : O(n)
+ * -> Int Array에 존재하는 유니크한 요소 만큼 필요함.
+ */
+fun topKFrequent01(nums: IntArray, k: Int): IntArray {
+    val map = mutableMapOf<Int, Int>()
+    for(num in nums) {
+        map[num] = map.getOrDefault(num, 0) + 1
+    }
+
+    // count List 초기화
+    // map의 value는 nums Size를 넘을 수 없음.
+    val countList = Array(nums.size + 1) { mutableListOf<Int>() }
+    for ((key, value) in map) {
+        countList[value].add(key)
+    }
+
+    val result = mutableListOf<Int>()
+    for (i in countList.size - 1 downTo 0) {
+        for (num in countList[i]) {
+            result.add(num)
+            if (result.size == k) {
+                return result.toIntArray()
+            }
+        }
+    }
+    return result.toIntArray()
+}

top-k-frequent-elements/heypaprika.py

@@ -0,0 +1,16 @@
+# Big-O 예상 : O(nlog(n))
+import heapq
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+
+        num_dict = {}
+        for num in nums:
+            num_dict[num] = num_dict.get(num, 0) + 1
+        heap = []
+        for k_, v in num_dict.items():
+            heapq.heappush(heap, [-v, k_])
+        ans = []
+        for i in range(k):
+            ans.append(heapq.heappop(heap)[1])
+        return ans
+