Merge branch 'DaleStudy:main' into main

Author: yolophg

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/pmjuu.py

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

house-robber/limlimjo.js

@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function(nums) {
+    // 1. nums 배열 0일 때와 1일 때
+    if (nums.length === 0) return 0;
+    if (nums.length === 1) return nums[0];
+
+    // 2. i=1일 때
+    nums[1] = Math.max(nums[0], nums[1]);
+    
+    // 3. i=2일 때부터 for문 순회
+    for (let i=2; i<nums.length; i++) {
+        nums[i] = Math.max(nums[i-2] + nums[i], nums[i-1])
+    }
+    return nums[nums.length-1];
+};
+
+// 시간복잡도와 공간복잡도
+// 시간복잡도: 배열의 길이 n 만큼 for문 순회하므로 -> O(n)
+// 공간복잡도: nums 배열 그대로 수정하여 계산 -> O(1)

house-robber/pmjuu.py

@@ -0,0 +1,16 @@
+from typing import List
+
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        if len(nums) == 1:
+            return nums[0]
+        
+        # prev1: 이전 집까지의 최대 이익
+        # prev2: 전전 집까지의 최대 이익
+        prev1, prev2 = 0, 0
+        for num in nums:
+            temp = prev1
+            prev1 = max(prev2 + num, prev1) # 현재 집을 털었을 때와 안 털었을 때 중 더 큰 이익 선택
+            prev2 = temp
+        
+        return prev1

longest-consecutive-sequence/limlimjo.js

@@ -0,0 +1,35 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var longestConsecutive = function(nums) {
+    // 첫 번째 정렬을 한다.
+    if (nums.length === 0) {
+        return 0;
+    }
+
+    nums.sort((a, b) => a - b); // 오름차순으로 정렬
+    console.log(nums);
+
+    // 두 번째 숫자가 1씩 계속해서 증가하는 구간을 찾는다.
+    let longest = 0;
+    let length = 1;
+
+    for (let i=0; i<nums.length-1; i++) {
+        if (nums[i] === nums[i+1]) {
+            continue;
+        }
+        // 연속해서 1씩 증가하는 구간 찾기
+        if (nums[i+1] - nums[i] === 1) {
+            length += 1;
+        } else {
+            longest = Math.max(longest, length);
+            length = 1;
+        }
+    }
+    return Math.max(longest, length);
+};
+
+// 시간복잡도와 공간복잡도
+// 시간복잡도: 정렬 사용(O(nlogn)) + for문으로 배열 탐색(O(n)) = O(nlogn)
+// 공간복잡도: O(1)

longest-consecutive-sequence/pmjuu.py

@@ -0,0 +1,22 @@
+from typing import List
+
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        # Convert to set for O(1) lookups
+        num_set = set(nums)
+        longest_length = 0
+
+        for num in num_set:
+            # Only start counting if num is the start of a sequence
+            if num - 1 not in num_set:
+                current_num = num
+                current_length = 1
+
+                # Count the length of the sequence
+                while current_num + 1 in num_set:
+                    current_num += 1
+                    current_length += 1
+
+                longest_length = max(longest_length, current_length)
+        
+        return longest_length

top-k-frequent-elements/limlimjo.js

@@ -0,0 +1,32 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+var topKFrequent = function(nums, k) {
+    let map = new Map(); // key에는 해당되는 숫자, value에는 해당되는 숫자의 갯수
+
+    // 숫자별 빈도수
+    nums.forEach((num) => {
+        map.set(num, (map.get(num) || 0) + 1);
+    });
+
+    // 결과를 배열로 바꿔주고 내림차순 정렬
+    let sortedResult = Array.from(map.entries()).sort((a,b) => b[1] - a[1]);
+    //console.log(sortedResult);
+    //console.log(sortedResult.slice(0,k));
+
+    // k갯수의 숫자 반환
+    return sortedResult.slice(0,k).map(item => item[0]);
+};
+
+// 여기서 위 코드의 시간복잡도와 공간복잡도를 생각해보자...
+// 시간복잡도 => O(m log m) ** 더 개선할 방법 찾아보기
+// forEach 통한 배열 순회: 배열의 크기가 n이라고 한다면 O(n)
+// sortedResult (정렬): O(m log m)
+// k갯수의 숫자 반환: k개 항목에 대해 연산하니까 O(k)
+
+// 공간복잡도 => O(n)
+// map의 크기: 배열의 크기가 n이라고 한다면 O(n)
+// sortedResult: O(m)
+// k개 숫자 저장: O(k)

top-k-frequent-elements/pmjuu.py

@@ -0,0 +1,24 @@
+from collections import Counter
+from typing import List
+
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        # 빈도 계산
+        count = Counter(nums)
+        n = len(nums)
+        
+        # 빈도수를 기준으로 버킷 생성 (0에서 n까지)
+        buckets = [[] for _ in range(n + 1)]
+        
+        # 각 숫자를 해당 빈도수의 버킷에 추가
+        for num, freq in count.items():
+            buckets[freq].append(num)
+        
+        # 빈도가 높은 순서대로 k개의 숫자를 추출
+        result = []
+        for freq in range(n, 0, -1):
+            if buckets[freq]:
+                result.extend(buckets[freq])
+                
+                if len(result) == k:
+                    return result

valid-palindrome/limlimjo.js

@@ -0,0 +1,23 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isPalindrome = function(s) {
+    // 1. 문자열을 다 소문자로 바꾸고, 알파벳/숫자 아닌 거 다 제거
+    if (s.length === 1) {
+        return true;
+    } else {
+        let lcLetter = s.toLowerCase().replace(/[^a-z0-9]/g, '');
+        //console.log(lcLetter);
+
+        // 2. 문자열이 앞에서 시작할 때와 뒤에서 시작할 때 같으면 true, 아니면 false
+        if(lcLetter) {
+            for(let i=0; i<Math.floor(lcLetter.length/2); i++) {
+                if (lcLetter[i] !== lcLetter[lcLetter.length - 1 - i]) return false;
+            }
+            return true;
+        } else {
+            return true;
+        }
+    }
+};

valid-palindrome/pmjuu.py

@@ -0,0 +1,21 @@
+class Solution:
+    def isPalindrome(self, s: str) -> bool:
+        # two pointer
+        left, right = 0, len(s) - 1
+
+        while left < right:
+            # compare only alphanumeric characters
+            while left < right and not s[left].isalnum():
+                left += 1
+            while left < right and not s[right].isalnum():
+                right -= 1
+            
+            # compare with lowercase
+            if s[left].lower() != s[right].lower():
+                return False
+            
+            # move pointers
+            left += 1
+            right -= 1
+        
+        return True